diff --git a/.circleci/config.yml b/.circleci/config.yml index 7b3c35df..34e4803e 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -41,18 +41,8 @@ commands: - run: name: cargo build command: cargo build - checkout-gcp-grpc: + setup-gcp-grpc: steps: - - add_ssh_keys: - fingerprints: - - "f1:d3:a1:e0:b1:cc:60:80:e5:bd:fa:f9:9c:3f:93:6f" - - run: - name: Checkout gcp-grpc - command: git clone git@github.com:mozilla-services/mozilla-rust-sdk.git - - run: - name: Adjust gcp-grpc dep path - # Switch it into the working dir so it's sent to Docker - command: sed -i "s/..\/mozilla-rust-sdk/mozilla-rust-sdk/" Cargo.toml - run: name: Install grpcio dependencies command: sudo apt-get update && sudo apt-get install -y cmake golang-go @@ -119,9 +109,9 @@ jobs: - image: circleci/rust:latest steps: - checkout - - checkout-gcp-grpc - setup-rust - setup-rust-check + - setup-gcp-grpc - rust-check - rust-clippy @@ -141,8 +131,8 @@ jobs: MYSQL_DATABASE: syncstorage steps: - checkout - - checkout-gcp-grpc - setup-rust + - setup-gcp-grpc # XXX: currently the time needed to setup-sccache negates its savings #- setup-sccache #- restore-sccache-cache diff --git a/Cargo.toml b/Cargo.toml index 046a70af..d7fa17d2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,7 +30,7 @@ docopt = "1.1.0" env_logger = "0.7.1" failure = "0.1.6" futures = { version = "0.3", features = ["compat"] } -googleapis-raw = { version = "0", path = "../mozilla-rust-sdk/googleapis-raw" } +googleapis-raw = { version = "0", path = "vendor/mozilla-rust-sdk/googleapis-raw" } grpcio = { version = "0.5.0-alpha.5" } lazy_static = "1.4.0" hawk = "3.0.0" diff --git a/vendor/mozilla-rust-sdk/.gitignore b/vendor/mozilla-rust-sdk/.gitignore new file mode 100644 index 00000000..81ecda8c --- /dev/null +++ b/vendor/mozilla-rust-sdk/.gitignore @@ -0,0 +1,4 @@ +/target +**/*.rs.bk +Cargo.lock +.env \ No newline at end of file diff --git a/vendor/mozilla-rust-sdk/.gitmodules b/vendor/mozilla-rust-sdk/.gitmodules new file mode 100644 index 00000000..9b314a31 --- /dev/null +++ b/vendor/mozilla-rust-sdk/.gitmodules @@ -0,0 +1,3 @@ +[submodule "googleapis-raw/grpc"] + path = googleapis-raw/grpc + url = https://github.com/grpc/grpc.git diff --git a/vendor/mozilla-rust-sdk/Cargo.toml b/vendor/mozilla-rust-sdk/Cargo.toml new file mode 100644 index 00000000..5d42939d --- /dev/null +++ b/vendor/mozilla-rust-sdk/Cargo.toml @@ -0,0 +1,5 @@ +[workspace] +members = [ + "googleapis", + "googleapis-raw", +] diff --git a/vendor/mozilla-rust-sdk/LICENSE.md b/vendor/mozilla-rust-sdk/LICENSE.md new file mode 100644 index 00000000..79c2b54d --- /dev/null +++ b/vendor/mozilla-rust-sdk/LICENSE.md @@ -0,0 +1,4 @@ +This library is subject to the terms of the Apache 2.0 license. If a +copy of the APACHE-2 license is not distributed with these files, you +can obtain one from https://www.apache.org/licenses/LICENSE-2.0.html + diff --git a/vendor/mozilla-rust-sdk/README.md b/vendor/mozilla-rust-sdk/README.md new file mode 100644 index 00000000..96c11420 --- /dev/null +++ b/vendor/mozilla-rust-sdk/README.md @@ -0,0 +1,6 @@ +# Rust bindings for Google APIs + +See [`googleapis-raw`](googleapis-raw) for raw bindings based on +[`grpcio`](https://github.com/pingcap/grpc-rs). + +See [`googleapis`](googleapis) for high-level bindings (not ready for use yet). diff --git a/vendor/mozilla-rust-sdk/docker/.gitignore b/vendor/mozilla-rust-sdk/docker/.gitignore new file mode 100644 index 00000000..56de6607 --- /dev/null +++ b/vendor/mozilla-rust-sdk/docker/.gitignore @@ -0,0 +1 @@ +files/credentials.json \ No newline at end of file diff --git a/vendor/mozilla-rust-sdk/docker/Dockerfile b/vendor/mozilla-rust-sdk/docker/Dockerfile new file mode 100644 index 00000000..f7400a88 --- /dev/null +++ b/vendor/mozilla-rust-sdk/docker/Dockerfile @@ -0,0 +1,30 @@ +FROM rust:1.36.0 + +RUN apt-get update -qq && apt-get install -y clang + +# Install Gcloud CLI +RUN curl https://sdk.cloud.google.com | bash +ENV PATH $PATH:/root/google-cloud-sdk/bin/ + +# Install CMake, required by Rust crates +RUN wget -qO- "https://cmake.org/files/v3.15/cmake-3.15.1-Linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local + +# Install Protobuf, gmock folder is created to make autogen.sh script work +RUN mkdir /protobuf-2.7.0 +WORKDIR /protobuf-2.7.0 +RUN curl -OL https://chromium.googlesource.com/external/github.com/google/protobuf/+archive/2.7.0.tar.gz \ + && tar -xvf 2.7.0.tar.gz \ + && mkdir -p gmock \ + && ./autogen.sh \ + && ./configure \ + && make install + +# Install Go +RUN curl -s https://dl.google.com/go/go1.12.7.linux-amd64.tar.gz | tar -v -C /usr/local -xz +ENV PATH $PATH:/usr/local/go/bin + +# copy Google credentials configuration and set env var +COPY files/credentials.json /root/credentials.json +ENV GOOGLE_APPLICATION_CREDENTIALS /root/credentials.json + +WORKDIR /googleapis-rs diff --git a/vendor/mozilla-rust-sdk/docker/README.md b/vendor/mozilla-rust-sdk/docker/README.md new file mode 100644 index 00000000..719e4bf2 --- /dev/null +++ b/vendor/mozilla-rust-sdk/docker/README.md @@ -0,0 +1,26 @@ +# Docker Setup + +On some operating systems, e.g. Mac OSX, the setup is not working fully or the installation of a few programming languages and libraries on the host system is not desired. For this reason a Docker setup is available. It is based on a Docker image that comes with a recent Rust toolchain. + +## Installation + +Install Docker on your operating system, e.g. Docker Desktop on Mac OSX, also install [docker-compose](https://docs.docker.com/compose/install/). To build the Docker image run: + +``` +docker-compose build rust +``` + +Then to start the container and connect to it + +``` +docker-compose run rust /bin/bash +``` + +this starts a shell in the container. The project repository is mounted into the image. + + +## Google Authentication + +In order to run all examples inside the Docker container, the setup requires the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to be set, pointing to the Google credentials file. For this the file `files/credentials.json` is copied into the Docker image. +Therefore copy the credentials file into this location to make the credentials available in the image. **Note**, this file +is not under version control. diff --git a/vendor/mozilla-rust-sdk/docker/docker-compose.yml b/vendor/mozilla-rust-sdk/docker/docker-compose.yml new file mode 100644 index 00000000..bb0128be --- /dev/null +++ b/vendor/mozilla-rust-sdk/docker/docker-compose.yml @@ -0,0 +1,11 @@ +version: "3" +services: + rust: + build: + context: . + dockerfile: Dockerfile + volumes: + - ..:/googleapis-rs + tty: true + stdin_open: true + working_dir: /googleapis-rs diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/.gitignore b/vendor/mozilla-rust-sdk/googleapis-raw/.gitignore new file mode 100644 index 00000000..68db51f0 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/.gitignore @@ -0,0 +1 @@ +grpc/ \ No newline at end of file diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/Cargo.toml b/vendor/mozilla-rust-sdk/googleapis-raw/Cargo.toml new file mode 100644 index 00000000..6843caab --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "googleapis-raw" +version = "0.0.1" +authors = ["Ferrous Systems"] +edition = "2018" + +[dependencies] +futures = "0.1.28" +grpcio = "0.5.0-alpha.1" +protobuf = "= 2.7.0" + +[dev-dependencies] +slog = "2.5.0" +slog-scope = "4.1.1" +slog-term = "2.4.1" +slog-stdlog = "3.0.2" +slog-async = "2.3.0" +log = "0.4.7" diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/README.md b/vendor/mozilla-rust-sdk/googleapis-raw/README.md new file mode 100644 index 00000000..c10ff7ba --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/README.md @@ -0,0 +1,92 @@ +# googleapis-raw + +These are raw bindings for Google APIs based on [`grpcio`](https://github.com/pingcap/grpc-rs). + +## Documentation + +To generate and open documentation, run: + +``` +cargo doc --open +``` + +## Examples + +To run hand-written examples, try: + +``` +cargo run --example spanner-query +cargo run --example bigtable-query +``` + +## Setting up Google Cloud SDK + +Before running examples, make sure the Google Cloud SDK is set up in your environment. +If you need help, follow these guides: + +1. [Installing the SDK](https://cloud.google.com/sdk/install) +2. [Setting up the SDK](https://cloud.google.com/sdk/docs/initializing) +3. [Getting started with Authentication](https://cloud.google.com/docs/authentication/getting-started) + +As a final check: + +* Run `gcloud info` to see the SDK configuration. +* Run `echo $GOOGLE_APPLICATION_CREDENTIALS` to verify that the credentials have been set up. +* Run `gcloud auth login` to login into Google Cloud + +There is Docker setup available that installs all necessary tools, libraries, see the [README](../docker/README.md) +inside the `./docker` folder. + + +Useful links for setting up specific Google services: + +* [Setting up Spanner](https://cloud.google.com/spanner/docs/getting-started/set-up) +* [Installing the Cloud SDK for Cloud Bigtable](https://cloud.google.com/bigtable/docs/installing-cloud-sdk) +* [Quickstart using the Pub/Sub CLI tool](https://cloud.google.com/pubsub/docs/quickstart-cli) + +## Generating Rust bindings from `.proto` files + +**NOTE:** You do not need to do this step. Rust bindings are already included in this repository. + +But if you still want to regenerate them from scratch, run: + +``` +./generate.sh +``` + +This requires the installation of [protobuf](https://google.github.io/proto-lens/installing-protoc.html) library +and [protoc-gen-rust](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-codegen), a plugin +for protobuf. The installed protobuf version and the protobuf crate should have the same version, e.g. `2.7.0`. +Installation of the protoc-gen-rust plugin is done via `cargo`: + +``` +cargo install protobuf-codegen +``` + +Make sure the `protoc-gen-rust` binary is available in your `$PATH` env variable. + + +## Google Cloud Console + +Links to Google Cloud Console for our testing environment: + +* [Spanner Console](https://console.cloud.google.com/spanner/instances?project=mozilla-rust-sdk-dev) +* [Bigtable Console](https://console.cloud.google.com/bigtable/instances?project=mozilla-rust-sdk-dev) +* [Pub/Sub Console](https://console.cloud.google.com/cloudpubsub/topic/detail/mytopic?project=mozilla-rust-sdk-dev) + +## References + +Google APIs and their `.proto` files: + +* [Spanner](https://github.com/googleapis/googleapis/tree/master/google/spanner) +* [Bigtable](https://github.com/googleapis/googleapis/tree/master/google/bigtable) +* [Pub/Sub](https://github.com/googleapis/googleapis/tree/master/google/pubsub) + +Golang clients: + +* [Spanner client](https://github.com/googleapis/google-cloud-go/tree/master/spanner) + ([docs](https://godoc.org/cloud.google.com/go/spanner)) +* [Bigtable client](https://github.com/googleapis/google-cloud-go/tree/master/bigtable) + ([docs](https://godoc.org/cloud.google.com/go/bigtable)) +* [Pub/Sub client](https://github.com/googleapis/google-cloud-go/tree/master/pubsub) + ([docs](https://godoc.org/cloud.google.com/go/pubsub)) diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-helloworld.rs b/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-helloworld.rs new file mode 100644 index 00000000..f4e9d26f --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-helloworld.rs @@ -0,0 +1,211 @@ +use std::collections::HashMap; +use std::error::Error; +use std::sync::Arc; +use std::time::{SystemTime, UNIX_EPOCH}; + +use futures::prelude::*; +use googleapis_raw::bigtable::admin::v2::{ + bigtable_instance_admin::GetClusterRequest, + bigtable_instance_admin_grpc::BigtableInstanceAdminClient, + bigtable_table_admin::CreateTableRequest, bigtable_table_admin::DeleteTableRequest, + bigtable_table_admin::ListTablesRequest, bigtable_table_admin_grpc::BigtableTableAdminClient, + instance::Cluster, table::ColumnFamily, table::GcRule, table::Table, +}; +use googleapis_raw::bigtable::v2::{ + bigtable::MutateRowsRequest, bigtable::MutateRowsRequest_Entry, bigtable_grpc::BigtableClient, + data::Mutation, data::Mutation_SetCell, +}; +use googleapis_raw::empty::Empty; +use grpcio::{Channel, ChannelBuilder, ChannelCredentials, ClientUnaryReceiver, EnvBuilder}; +use protobuf::well_known_types::Duration; +use protobuf::RepeatedField; + +fn timestamp() -> u128 { + let start = SystemTime::now(); + let time = start + .duration_since(UNIX_EPOCH) + .expect("Failed to fetch timestamp"); + time.as_micros() +} + +/// Create a new channel used for the different types of clients +fn connect(endpoint: &str) -> Channel { + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = + ChannelCredentials::google_default_credentials().expect("No Google credentials found"); + + // Create a channel to connect to Gcloud. + ChannelBuilder::new(env.clone()) + // Set the max size to correspond to server-side limits. + .max_send_message_len(1 << 28) + .max_receive_message_len(1 << 28) + .secure_connect(&endpoint, creds) +} + +/// Returns the cluster information +/// +fn get_cluster( + client: &BigtableInstanceAdminClient, + cluster_id: &String, +) -> ::grpcio::Result { + println!("Get cluster information"); + let mut request = GetClusterRequest::new(); + request.set_name(cluster_id.to_string()); + client.get_cluster(&request) +} + +/// Lists all tables for a given cluster +/// +fn list_tables(client: &BigtableTableAdminClient, instance_id: &String) { + println!("List all existing tables"); + let mut request = ListTablesRequest::new(); + request.set_parent(instance_id.clone()); + match client.list_tables(&request) { + Ok(response) => { + response + .get_tables() + .iter() + .for_each(|table| println!(" table: {:?}", table)); + } + Err(error) => println!("Failed to list tables: {}", error), + } +} + +/// Create a new table in the BigTable cluster +/// +fn create_table( + client: &BigtableTableAdminClient, + instance_id: &String, + table_name: &String, + table: Table, +) -> ::grpcio::Result { + println!("Creating table {}", table_name); + let mut request = CreateTableRequest::new(); + request.set_parent(instance_id.clone()); + request.set_table(table); + request.set_table_id("hello-world".to_string()); + client.create_table(&request) +} + +/// Deletes a table asynchronously, returns a future +fn delete_table_async( + client: &BigtableTableAdminClient, + table_name: &String, +) -> grpcio::Result> { + println!("Deleting the {} table", table_name); + let mut request = DeleteTableRequest::new(); + request.set_name(table_name.clone()); + client.delete_table_async(&request) +} + +fn main() -> Result<(), Box> { + // BigTable project id + let project_id = String::from("mozilla-rust-sdk-dev"); + // The BigTable instance id + let instance_id = String::from("projects/mozilla-rust-sdk-dev/instances/mozilla-rust-sdk"); + // The cluster id + let cluster_id = String::from( + "projects/mozilla-rust-sdk-dev/instances/mozilla-rust-sdk/clusters/mozilla-rust-sdk-c1", + ); + // common table endpoint + let endpoint = "bigtable.googleapis.com"; + // Google Cloud configuration. + let admin_endpoint = "bigtableadmin.googleapis.com"; + // The table name + let table_name = + String::from("projects/mozilla-rust-sdk-dev/instances/mozilla-rust-sdk/tables/hello-world"); + + let column_family_id = "cf1"; + + // Create a Bigtable client. + let channel = connect(admin_endpoint); + let client = BigtableInstanceAdminClient::new(channel.clone()); + + // display cluster information + let cluster = get_cluster(&client, &cluster_id)?; + dbg!(cluster); + + // create admin client for tables + let admin_client = BigtableTableAdminClient::new(channel.clone()); + + // display current tables + list_tables(&admin_client, &instance_id); + + // create a new table with a custom column family / gc rule + let mut duration = Duration::new(); + duration.set_seconds(60 * 60 * 24 * 5); + let mut gc_rule = GcRule::new(); + gc_rule.set_max_num_versions(2); + gc_rule.set_max_age(duration); + let mut column_family = ColumnFamily::new(); + column_family.set_gc_rule(gc_rule); + let mut hash_map = HashMap::new(); + hash_map.insert(column_family_id.to_string(), column_family); + let mut table = Table::new(); + table.set_column_families(hash_map); + match create_table(&admin_client, &instance_id, &table_name, table) { + Ok(table) => println!(" table {:?} created", table), + Err(error) => println!(" failed to created table: {}", error), + } + + // insert entries into new table + println!("Insert entries into table"); + + let greetings = vec!["Hello World!", "Hello Cloud!", "Hello Rust!"]; + let mut mutation_requests = Vec::new(); + let column = "greeting"; + for (i, greeting) in greetings.iter().enumerate() { + let row_key = format!("greeting{}", i); + + let mut set_cell = Mutation_SetCell::new(); + set_cell.set_column_qualifier(column.to_string().into_bytes()); + set_cell.set_timestamp_micros(-1); + set_cell.set_value(greeting.to_string().into_bytes()); + set_cell.set_family_name(column_family_id.to_string()); + + let mut mutation = Mutation::new(); + mutation.set_set_cell(set_cell); + + let mut request = MutateRowsRequest_Entry::new(); + request.set_row_key(row_key.into_bytes()); + request.set_mutations(RepeatedField::from_vec(vec![mutation])); + + mutation_requests.push(request); + } + + let channel = connect(endpoint); + let client = BigtableClient::new(channel.clone()); + let mut request = MutateRowsRequest::new(); + request.set_table_name(table_name.to_string()); + request.set_entries(RepeatedField::from_vec(mutation_requests)); + + // apply changes and check responses + let response = client + .mutate_rows(&request)? + .collect() + .into_future() + .wait()?; + for response in response.iter() { + for entry in response.get_entries().iter() { + let status = entry.get_status(); + println!( + " entry index: {}, status: {} - {}", + entry.get_index(), + status.code, + status.message + ); + } + } + + // display all tables, should include new table + list_tables(&admin_client, &instance_id); + + // delete the table + delete_table_async(&admin_client, &table_name)?.wait()?; + + // list of tables should not have deleted table + list_tables(&admin_client, &instance_id); + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-query.rs b/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-query.rs new file mode 100644 index 00000000..f547dd20 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/examples/bigtable-query.rs @@ -0,0 +1,39 @@ +use std::error::Error; +use std::sync::Arc; + +use futures::prelude::*; +use googleapis_raw::bigtable::v2::{bigtable::ReadRowsRequest, bigtable_grpc::BigtableClient}; +use grpcio::{ChannelBuilder, ChannelCredentials, EnvBuilder}; + +fn main() -> Result<(), Box> { + // An example database inside Mozilla's Bigtable instance. + let table = "projects/mozilla-rust-sdk-dev/instances/mozilla-rust-sdk/tables/prezzy"; + + // Google Cloud configuration. + let endpoint = "bigtable.googleapis.com:443"; + + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = ChannelCredentials::google_default_credentials()?; + + // Create a Bigtable client. + let chan = ChannelBuilder::new(env.clone()) + // Set the max size to correspond to server-side limits. + .max_send_message_len(1 << 28) + .max_receive_message_len(1 << 28) + .secure_connect(&endpoint, creds); + let client = BigtableClient::new(chan); + + // Create a request to read all rows. + let mut req = ReadRowsRequest::new(); + req.table_name = table.to_string(); + + // Iterate over the rows and print them. + let mut stream = client.read_rows(&req)?; + while let (Some(row), s) = stream.into_future().wait().map_err(|(e, _)| e)? { + stream = s; + dbg!(row); + } + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/examples/pubsub-publisher.rs b/vendor/mozilla-rust-sdk/googleapis-raw/examples/pubsub-publisher.rs new file mode 100644 index 00000000..f8fae078 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/examples/pubsub-publisher.rs @@ -0,0 +1,191 @@ +use std::collections::HashMap; +use std::error::Error; +use std::sync::Arc; +use std::time::SystemTime; + +use futures::prelude::*; +use googleapis_raw::pubsub::v1::{ + pubsub::AcknowledgeRequest, pubsub::ExpirationPolicy, pubsub::GetSubscriptionRequest, + pubsub::GetTopicRequest, pubsub::PublishRequest, pubsub::PublishResponse, + pubsub::PubsubMessage, pubsub::PullRequest, pubsub::PushConfig, pubsub::Subscription, + pubsub::Topic, pubsub_grpc::PublisherClient, pubsub_grpc::SubscriberClient, +}; +use grpcio::{Channel, ChannelBuilder, ChannelCredentials, ClientUnaryReceiver, EnvBuilder}; +use protobuf::RepeatedField; + +/// Creates a topic or finds an existing one, then returns the topic +/// +fn find_or_create_topic(client: &PublisherClient, topic_name: &str) -> ::grpcio::Result { + // find topic + println!("Finding topic {}", topic_name); + let mut request = GetTopicRequest::new(); + request.set_topic(topic_name.to_string()); + if let Ok(topic) = client.get_topic(&request) { + println!("Found topic: {}", topic.get_name()); + return Ok(topic); + } else { + println!("Topic not found"); + } + + // otherwise create topic + println!("Creating topic {}", topic_name); + let mut labels = HashMap::new(); + labels.insert("environment".to_string(), "test".to_string()); + let mut topic = Topic::new(); + topic.set_name(topic_name.to_string()); + topic.set_labels(labels); + client.create_topic(&topic) +} + +/// Creates a subscription or finds an existing one +/// +fn find_or_create_subscription( + client: &SubscriberClient, + subscription_name: &str, + topic_name: &str, +) -> ::grpcio::Result { + // find subscription + println!( + "Finding subscription {} for topic {}", + subscription_name, topic_name + ); + let mut request = GetSubscriptionRequest::new(); + request.set_subscription(subscription_name.to_string()); + if let Ok(subscription) = client.get_subscription(&request) { + println!("Found subscription: {}", subscription.get_name()); + return Ok(subscription); + } else { + println!("Subscription not found"); + } + + // create a new subscription + println!("Creating a new subscription {}", subscription_name); + let mut labels = HashMap::new(); + labels.insert("environment".to_string(), "test".to_string()); + let mut attributes = HashMap::new(); + attributes.insert("attribute".to_string(), "hello".to_string()); + let mut push_config = PushConfig::new(); + let mut expiration_policy = ExpirationPolicy::new(); + let mut expiration_duration = protobuf::well_known_types::Duration::new(); + let mut subscription = Subscription::new(); + push_config.set_attributes(attributes); + expiration_duration.set_seconds(60 * 60 * 48); + expiration_policy.set_ttl(expiration_duration.clone()); + subscription.set_name(subscription_name.to_string()); + subscription.set_topic(topic_name.to_string()); + subscription.set_ack_deadline_seconds(20); + // subscription.set_expiration_policy(expiration_policy); + // subscription.set_message_retention_duration(expiration_duration.clone()); + // subscription.set_push_config(push_config); + // subscription.set_labels(labels); + + client.create_subscription(&subscription) +} + +fn timestamp_in_seconds() -> u64 { + let timestamp = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .unwrap(); + timestamp.as_secs() +} + +/// Creates a new PubSubMessage instance +/// +fn create_pubsub_msg(message: &str) -> PubsubMessage { + println!("Publishing message: {}", message); + let mut timestamp = ::protobuf::well_known_types::Timestamp::new(); + timestamp.set_seconds(timestamp_in_seconds() as i64); + + let mut pubsub_msg = PubsubMessage::new(); + pubsub_msg.set_data(message.to_string().into_bytes()); + pubsub_msg.set_publish_time(timestamp); + pubsub_msg +} + +/// Publishes a message asynchronously, returning a future +/// +fn publish_msg_async( + client: &PublisherClient, + topic: &Topic, + messages: Vec, +) -> ::grpcio::Result> { + let pub_messages = messages.iter().map(|msg| create_pubsub_msg(msg)).collect(); + + let mut request = PublishRequest::new(); + request.set_topic(topic.get_name().to_string()); + request.set_messages(RepeatedField::from_vec(pub_messages)); + client.publish_async(&request) +} + +/// Create a new channel used for the different types of clients +/// +fn connect(endpoint: &str) -> Channel { + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = + ChannelCredentials::google_default_credentials().expect("No Google redentials found"); + + // Create a channel to connect to Gcloud. + ChannelBuilder::new(env.clone()) + // Set the max size to correspond to server-side limits. + .max_send_message_len(1 << 28) + .max_receive_message_len(1 << 28) + .secure_connect(&endpoint, creds) +} + +fn main() -> Result<(), Box> { + // API endpoint + let endpoint = "pubsub.googleapis.com"; + // GCloud project id + let project_id = "mozilla-rust-sdk-dev"; + + // create client + let channel = connect(&endpoint); + let publisher = PublisherClient::new(channel.clone()); + + // get topic + let topic_name = format!("projects/{}/topics/greetings", project_id); + let topic = dbg!(find_or_create_topic(&publisher, &topic_name)?); + + // publish a number of greeting messages + let greetings = vec!["hello", "hi", "hola", "bonjour", "ahoi"]; + let messages = greetings.iter().map(|g| g.to_string()).collect(); + publish_msg_async(&publisher, &topic, messages)?.wait()?; + + // create a subscriber to consume these messages + let subscription_name = format!("projects/{}/subscriptions/sub-greetings", project_id); + let subscriber = SubscriberClient::new(channel.clone()); + + // get subscription + let subscription = find_or_create_subscription(&subscriber, &subscription_name, &topic_name)?; + + // Pubsub Subscription Pull, receive all messages + println!("Pulling messages from subscription {:?}", subscription); + let mut request = PullRequest::new(); + request.set_subscription(subscription_name.to_string()); + request.set_max_messages(10); + + loop { + let future = subscriber.pull_async(&request)?; + let response = future.wait()?; + let pubsub_messages = response.get_received_messages(); + + println!("Handling {} messages", pubsub_messages.len()); + for pubsub_message in pubsub_messages { + println!(" >> message: {:?}", pubsub_message); + let ack_id = pubsub_message.get_ack_id().to_string(); + + let mut request = AcknowledgeRequest::new(); + request.set_subscription(subscription_name.to_string()); + request.set_ack_ids(RepeatedField::from_vec(vec![ack_id])); + subscriber.acknowledge(&request)?; + } + + // once all messages are handled leave + if pubsub_messages.is_empty() { + break; + } + } + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-db.rs b/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-db.rs new file mode 100644 index 00000000..bd933c5e --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-db.rs @@ -0,0 +1,261 @@ +use googleapis_raw::empty::Empty; +use googleapis_raw::longrunning::operations::GetOperationRequest; +use googleapis_raw::longrunning::operations_grpc::OperationsClient; +use googleapis_raw::spanner::admin::database::v1::{ + spanner_database_admin::CreateDatabaseRequest, spanner_database_admin::DropDatabaseRequest, + spanner_database_admin::GetDatabaseRequest, spanner_database_admin_grpc::DatabaseAdminClient, +}; +use googleapis_raw::spanner::v1::{ + mutation::Mutation, mutation::Mutation_Write, spanner::BeginTransactionRequest, + spanner::CommitRequest, spanner::CreateSessionRequest, spanner::Session, + spanner_grpc::SpannerClient, transaction::Transaction, transaction::TransactionOptions, + transaction::TransactionOptions_ReadWrite, +}; +use grpcio::{ + CallOption, Channel, ChannelBuilder, ChannelCredentials, ClientUnaryReceiver, EnvBuilder, + MetadataBuilder, +}; +use protobuf::well_known_types::{ListValue, Value}; +use protobuf::RepeatedField; +#[allow(unused_imports)] +use std::error::Error; +use std::sync::Arc; +use std::time::Duration; + +const CREATE_DATABASE: &str = "CREATE DATABASE music"; + +const CREATE_SINGER_TABLE: &str = "CREATE TABLE Singers ( + SingerId INT64 NOT NULL, + FirstName STRING(1024), + LastName STRING(1024), + SingerInfo BYTES(MAX), + ) PRIMARY KEY (SingerId)"; + +const CREATE_ALBUMS_TABLE: &str = "CREATE TABLE Albums ( + SingerId INT64 NOT NULL, + AlbumId INT64 NOT NULL, + AlbumTitle STRING(MAX), + ) PRIMARY KEY (SingerId, AlbumId), + INTERLEAVE IN PARENT Singers ON DELETE CASCADE"; + +/// A basic struct for a singer +/// +struct Singer { + pub id: i64, + pub first_name: String, + pub last_name: String, +} + +/// Waits until the operation is finished +/// +fn wait_operation_finished(channel: &Channel, operation: &str) { + let operations_client = OperationsClient::new(channel.clone()); + + let mut request = GetOperationRequest::new(); + request.set_name(operation.to_string()); + + loop { + println!("Checking operation: {}", operation); + match operations_client.get_operation(&request) { + Ok(response) => { + if response.get_done() { + println!("Operation {} finished", operation); + break; + } + + // wait instead + let wait_time = Duration::from_millis(250); + std::thread::sleep(wait_time); + } + Err(error) => { + println!("Failed to get operation"); + dbg!(error); + } + } + } +} + +/// Creates a new database if it does not exist yet. +/// +fn create_database_if_not_exists(channel: &Channel, database_name: &str, instance_id: &str) { + let client = DatabaseAdminClient::new(channel.clone()); + // find database + println!("Finding database {}", database_name); + let mut request = GetDatabaseRequest::new(); + request.set_name(database_name.to_string()); + if let Ok(database) = client.get_database(&request) { + println!("Found database: {}", database.get_name()); + return; + } else { + println!("Database not found"); + } + + // create a new database + println!("Create database {}", database_name); + let statements = vec![CREATE_SINGER_TABLE, CREATE_ALBUMS_TABLE] + .iter() + .map(|s| s.to_string()) + .collect(); + + let mut request = CreateDatabaseRequest::new(); + request.set_parent(instance_id.to_string()); + request.set_create_statement(CREATE_DATABASE.to_string()); + request.set_extra_statements(RepeatedField::from_vec(statements)); + let operation = client + .create_database(&request) + .expect("Failed to create database"); + dbg!(operation.clone()); + + // check that operation is finished + wait_operation_finished(&channel, operation.get_name()); +} + +/// Deletes a given database +/// +fn drop_database( + channel: &Channel, + database_name: &str, +) -> ::grpcio::Result> { + println!("Drop database {}", database_name); + let client = DatabaseAdminClient::new(channel.clone()); + + let mut request = DropDatabaseRequest::new(); + request.set_database(database_name.to_string()); + + client.drop_database_async(&request) +} + +/// Create a new session to communicate with Spanner +/// +fn create_session(client: &SpannerClient, database_name: &str) -> ::grpcio::Result { + let mut request = CreateSessionRequest::new(); + request.set_database(database_name.to_string()); + let mut meta = MetadataBuilder::new(); + meta.add_str("google-cloud-resource-prefix", database_name) + .expect("Failed to set meta data"); + meta.add_str("x-goog-api-client", "googleapis-rs") + .expect("Failed to set meta data"); + let opt = CallOption::default().headers(meta.build()); + client.create_session_opt(&request, opt) +} + +/// Create a new channel used for the different types of clients +/// +fn connect(endpoint: &str) -> Channel { + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = + ChannelCredentials::google_default_credentials().expect("No Google credentials found"); + + // Create a channel to connect to Gcloud. + ChannelBuilder::new(env.clone()) + // Set the max size to correspond to server-side limits. + .max_send_message_len(1 << 28) + .max_receive_message_len(1 << 28) + .secure_connect(&endpoint, creds) +} + +fn main() -> Result<(), Box> { + let endpoint = "spanner.googleapis.com"; + + // global project_id + let _project_id = "projects/mozilla-rust-sdk-dev"; + // spanner instance id + let instance_id = "projects/mozilla-rust-sdk-dev/instances/mozilla-spanner-dev"; + // database name + let database_name = + "projects/mozilla-rust-sdk-dev/instances/mozilla-spanner-dev/databases/music"; + + // create spanner admin client + let channel = connect(endpoint); + + // create database if it not already exists + create_database_if_not_exists(&channel, database_name, instance_id); + + // create session to communicate + let client = SpannerClient::new(channel.clone()); + let session = create_session(&client, database_name)?; + + // insert data into database by using a transaction + let client = SpannerClient::new(channel.clone()); + let mut request = BeginTransactionRequest::new(); + let mut read_write = TransactionOptions::new(); + read_write.set_read_write(TransactionOptions_ReadWrite::new()); + request.set_session(session.get_name().to_string()); + request.set_options(read_write); + let transaction = client.begin_transaction(&request)?; + + // the list of singers to add + let columns = vec![ + "SingerId".to_string(), + "FirstName".to_string(), + "LastName".to_string(), + ]; + let singers = vec![ + Singer { + id: 1, + first_name: "Marc".to_string(), + last_name: "Richards".to_string(), + }, + Singer { + id: 2, + first_name: "Catalina".to_string(), + last_name: "Smith".to_string(), + }, + Singer { + id: 3, + first_name: "Alice".to_string(), + last_name: "Trentor".to_string(), + }, + Singer { + id: 4, + first_name: "Lea".to_string(), + last_name: "Martin".to_string(), + }, + Singer { + id: 5, + first_name: "David".to_string(), + last_name: "Lomond".to_string(), + }, + ]; + + // collect all values + let mut list_values = Vec::new(); + for singer in singers { + let mut id = Value::new(); + id.set_string_value(singer.id.to_string()); + let mut first_name = Value::new(); + first_name.set_string_value(singer.first_name.clone()); + let mut last_name = Value::new(); + last_name.set_string_value(singer.last_name.clone()); + + let mut list = ListValue::new(); + list.set_values(RepeatedField::from_vec(vec![id, first_name, last_name])); + list_values.push(list); + } + + // create a suitable mutation with all values + println!("Preparing write mutation to add singers"); + let mut mutation_write = Mutation_Write::new(); + mutation_write.set_table("Singers".to_string()); + mutation_write.set_columns(RepeatedField::from_vec(columns)); + mutation_write.set_values(RepeatedField::from_vec(list_values)); + println!("Mutation write object"); + dbg!(mutation_write.clone()); + + // finally commit to database + println!("Commit data to database {}", database_name); + let mut commit = CommitRequest::new(); + commit.set_transaction_id(transaction.get_id().to_vec()); + commit.set_session(session.get_name().to_string()); + let mut mutation = Mutation::new(); + mutation.set_insert_or_update(mutation_write); + commit.set_mutations(RepeatedField::from_vec(vec![mutation])); + let response = client.commit(&commit)?; + dbg!(response); + + // delete database + // drop_database(&channel, database_name)?.wait()?; + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-query.rs b/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-query.rs new file mode 100644 index 00000000..86380eb5 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/examples/spanner-query.rs @@ -0,0 +1,53 @@ +use std::error::Error; +use std::sync::Arc; + +use futures::prelude::*; +use googleapis_raw::spanner::v1::{ + spanner::{CreateSessionRequest, ExecuteSqlRequest}, + spanner_grpc::SpannerClient, +}; +use grpcio::{CallOption, ChannelBuilder, ChannelCredentials, EnvBuilder, MetadataBuilder}; + +fn main() -> Result<(), Box> { + // An example database inside Mozilla's Spanner instance. + let database = "projects/mozilla-rust-sdk-dev/instances/mozilla-spanner-dev/databases/mydb"; + + // Google Cloud configuration. + let endpoint = "spanner.googleapis.com:443"; + + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = ChannelCredentials::google_default_credentials()?; + + // Create a Spanner client. + let chan = ChannelBuilder::new(env.clone()) + .max_send_message_len(100 << 20) + .max_receive_message_len(100 << 20) + .secure_connect(&endpoint, creds); + let client = SpannerClient::new(chan); + + // Connect to the instance and create a Spanner session. + let mut req = CreateSessionRequest::new(); + req.database = database.to_string(); + let mut meta = MetadataBuilder::new(); + meta.add_str("google-cloud-resource-prefix", database)?; + meta.add_str("x-goog-api-client", "googleapis-rs")?; + let opt = CallOption::default().headers(meta.build()); + let session = client.create_session_opt(&req, opt)?; + + // Prepare a SQL command to execute. + let mut req = ExecuteSqlRequest::new(); + req.session = session.get_name().to_string(); + req.sql = "select * from planets".to_string(); + + // Execute the command synchronously. + let out = client.execute_sql(&req)?; + dbg!(out); + + // Execute the command asynchronously. + let fut = client.execute_sql_async(&req)?; + let out = fut.wait()?; + dbg!(out); + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/generate.sh b/vendor/mozilla-rust-sdk/googleapis-raw/generate.sh new file mode 100755 index 00000000..1d77ce62 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/generate.sh @@ -0,0 +1,60 @@ +#!/bin/bash + +set -e +cd "$(dirname "$0")" + +if ! [[ -x "$(command -v grpc_rust_plugin)" ]]; then + echo "Error: grpc_rust_plugin was not found" + echo + echo "To install, run: cargo install grpcio-compiler" + exit 1 +fi + +echo "Pulling git submodules" +git submodule update --init --recursive + +apis=grpc/third_party/googleapis + +proto_files=" +grpc/src/proto/grpc/testing/empty.proto +" + +for proto in $proto_files; do + echo "Processing: $proto" + protoc \ + --rust_out=$PWD/src \ + --grpc_out=$PWD/src \ + --plugin=protoc-gen-grpc=`which grpc_rust_plugin` \ + --proto_path=grpc/src/proto/grpc/testing \ + $proto +done + +proto_dirs=" +bigtable/admin/cluster/v1 +bigtable/admin/table/v1 +bigtable/admin/v2 +bigtable/v1 +bigtable/v2 +iam/v1 +longrunning +pubsub/v1 +pubsub/v1beta2 +rpc +spanner/admin/database/v1 +spanner/admin/instance/v1 +spanner/v1 +" + +for dir in $proto_dirs; do + mkdir -p "$PWD/src/$dir" + + for proto in `find $apis/google/$dir/*.proto`; do + echo "Processing: $proto" + protoc \ + --rust_out="$PWD/src/$dir" \ + --grpc_out="$PWD/src/$dir" \ + --plugin=protoc-gen-grpc="`which grpc_rust_plugin`" \ + --proto_path="$apis" \ + $proto + done +done diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/mod.rs new file mode 100644 index 00000000..a3a6d96c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_data.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_data.rs new file mode 100644 index 00000000..02b42a77 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_data.rs @@ -0,0 +1,855 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Zone { + // message fields + pub name: ::std::string::String, + pub display_name: ::std::string::String, + pub status: Zone_Status, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Zone { + fn default() -> &'a Zone { + ::default_instance() + } +} + +impl Zone { + pub fn new() -> Zone { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string display_name = 2; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } + + // .google.bigtable.admin.cluster.v1.Zone.Status status = 3; + + + pub fn get_status(&self) -> Zone_Status { + self.status + } + pub fn clear_status(&mut self) { + self.status = Zone_Status::UNKNOWN; + } + + // Param is passed by value, moved + pub fn set_status(&mut self, v: Zone_Status) { + self.status = v; + } +} + +impl ::protobuf::Message for Zone { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + 3 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.status, 3, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.display_name); + } + if self.status != Zone_Status::UNKNOWN { + my_size += ::protobuf::rt::enum_size(3, self.status); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.display_name.is_empty() { + os.write_string(2, &self.display_name)?; + } + if self.status != Zone_Status::UNKNOWN { + os.write_enum(3, self.status.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Zone { + Zone::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Zone| { &m.name }, + |m: &mut Zone| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &Zone| { &m.display_name }, + |m: &mut Zone| { &mut m.display_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "status", + |m: &Zone| { &m.status }, + |m: &mut Zone| { &mut m.status }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Zone", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Zone { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Zone, + }; + unsafe { + instance.get(Zone::new) + } + } +} + +impl ::protobuf::Clear for Zone { + fn clear(&mut self) { + self.name.clear(); + self.display_name.clear(); + self.status = Zone_Status::UNKNOWN; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Zone { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Zone { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Zone_Status { + UNKNOWN = 0, + OK = 1, + PLANNED_MAINTENANCE = 2, + EMERGENCY_MAINENANCE = 3, +} + +impl ::protobuf::ProtobufEnum for Zone_Status { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Zone_Status::UNKNOWN), + 1 => ::std::option::Option::Some(Zone_Status::OK), + 2 => ::std::option::Option::Some(Zone_Status::PLANNED_MAINTENANCE), + 3 => ::std::option::Option::Some(Zone_Status::EMERGENCY_MAINENANCE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Zone_Status] = &[ + Zone_Status::UNKNOWN, + Zone_Status::OK, + Zone_Status::PLANNED_MAINTENANCE, + Zone_Status::EMERGENCY_MAINENANCE, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Zone_Status", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Zone_Status { +} + +impl ::std::default::Default for Zone_Status { + fn default() -> Self { + Zone_Status::UNKNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Zone_Status { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Cluster { + // message fields + pub name: ::std::string::String, + pub current_operation: ::protobuf::SingularPtrField, + pub display_name: ::std::string::String, + pub serve_nodes: i32, + pub default_storage_type: StorageType, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Cluster { + fn default() -> &'a Cluster { + ::default_instance() + } +} + +impl Cluster { + pub fn new() -> Cluster { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.longrunning.Operation current_operation = 3; + + + pub fn get_current_operation(&self) -> &super::operations::Operation { + self.current_operation.as_ref().unwrap_or_else(|| super::operations::Operation::default_instance()) + } + pub fn clear_current_operation(&mut self) { + self.current_operation.clear(); + } + + pub fn has_current_operation(&self) -> bool { + self.current_operation.is_some() + } + + // Param is passed by value, moved + pub fn set_current_operation(&mut self, v: super::operations::Operation) { + self.current_operation = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_current_operation(&mut self) -> &mut super::operations::Operation { + if self.current_operation.is_none() { + self.current_operation.set_default(); + } + self.current_operation.as_mut().unwrap() + } + + // Take field + pub fn take_current_operation(&mut self) -> super::operations::Operation { + self.current_operation.take().unwrap_or_else(|| super::operations::Operation::new()) + } + + // string display_name = 4; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } + + // int32 serve_nodes = 5; + + + pub fn get_serve_nodes(&self) -> i32 { + self.serve_nodes + } + pub fn clear_serve_nodes(&mut self) { + self.serve_nodes = 0; + } + + // Param is passed by value, moved + pub fn set_serve_nodes(&mut self, v: i32) { + self.serve_nodes = v; + } + + // .google.bigtable.admin.cluster.v1.StorageType default_storage_type = 8; + + + pub fn get_default_storage_type(&self) -> StorageType { + self.default_storage_type + } + pub fn clear_default_storage_type(&mut self) { + self.default_storage_type = StorageType::STORAGE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_default_storage_type(&mut self, v: StorageType) { + self.default_storage_type = v; + } +} + +impl ::protobuf::Message for Cluster { + fn is_initialized(&self) -> bool { + for v in &self.current_operation { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.current_operation)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.serve_nodes = tmp; + }, + 8 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.default_storage_type, 8, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.current_operation.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.display_name); + } + if self.serve_nodes != 0 { + my_size += ::protobuf::rt::value_size(5, self.serve_nodes, ::protobuf::wire_format::WireTypeVarint); + } + if self.default_storage_type != StorageType::STORAGE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(8, self.default_storage_type); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.current_operation.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.display_name.is_empty() { + os.write_string(4, &self.display_name)?; + } + if self.serve_nodes != 0 { + os.write_int32(5, self.serve_nodes)?; + } + if self.default_storage_type != StorageType::STORAGE_UNSPECIFIED { + os.write_enum(8, self.default_storage_type.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Cluster { + Cluster::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Cluster| { &m.name }, + |m: &mut Cluster| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "current_operation", + |m: &Cluster| { &m.current_operation }, + |m: &mut Cluster| { &mut m.current_operation }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &Cluster| { &m.display_name }, + |m: &mut Cluster| { &mut m.display_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "serve_nodes", + |m: &Cluster| { &m.serve_nodes }, + |m: &mut Cluster| { &mut m.serve_nodes }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "default_storage_type", + |m: &Cluster| { &m.default_storage_type }, + |m: &mut Cluster| { &mut m.default_storage_type }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Cluster", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Cluster { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Cluster, + }; + unsafe { + instance.get(Cluster::new) + } + } +} + +impl ::protobuf::Clear for Cluster { + fn clear(&mut self) { + self.name.clear(); + self.current_operation.clear(); + self.display_name.clear(); + self.serve_nodes = 0; + self.default_storage_type = StorageType::STORAGE_UNSPECIFIED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Cluster { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Cluster { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum StorageType { + STORAGE_UNSPECIFIED = 0, + STORAGE_SSD = 1, + STORAGE_HDD = 2, +} + +impl ::protobuf::ProtobufEnum for StorageType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(StorageType::STORAGE_UNSPECIFIED), + 1 => ::std::option::Option::Some(StorageType::STORAGE_SSD), + 2 => ::std::option::Option::Some(StorageType::STORAGE_HDD), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [StorageType] = &[ + StorageType::STORAGE_UNSPECIFIED, + StorageType::STORAGE_SSD, + StorageType::STORAGE_HDD, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("StorageType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for StorageType { +} + +impl ::std::default::Default for StorageType { + fn default() -> Self { + StorageType::STORAGE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for StorageType { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n/zones/[a-z][-a-z0-9]*\n\n\r\n\x05\x04\0\x02\0\x04\x12\x040\ + \x02,\x03\n\x0c\n\x05\x04\0\x02\0\x05\x12\x030\x02\x08\n\x0c\n\x05\x04\0\ + \x02\0\x01\x12\x030\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x030\x10\x11\n:\ + \n\x04\x04\0\x02\x01\x12\x033\x02\x1a\x1a-\x20The\x20name\x20of\x20this\ + \x20zone\x20as\x20it\x20appears\x20in\x20UIs.\n\n\r\n\x05\x04\0\x02\x01\ + \x04\x12\x043\x020\x12\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x033\x02\x08\n\ + \x0c\n\x05\x04\0\x02\x01\x01\x12\x033\t\x15\n\x0c\n\x05\x04\0\x02\x01\ + \x03\x12\x033\x18\x19\n.\n\x04\x04\0\x02\x02\x12\x036\x02\x14\x1a!\x20Th\ + e\x20current\x20state\x20of\x20this\x20zone.\n\n\r\n\x05\x04\0\x02\x02\ + \x04\x12\x046\x023\x1a\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x036\x02\x08\n\ + \x0c\n\x05\x04\0\x02\x02\x01\x12\x036\t\x0f\n\x0c\n\x05\x04\0\x02\x02\ + \x03\x12\x036\x12\x13\nX\n\x02\x04\x01\x12\x04:\0Q\x01\x1aL\x20An\x20iso\ + lated\x20set\x20of\x20Cloud\x20BigTable\x20resources\x20on\x20which\x20t\ + ables\x20can\x20be\x20hosted.\n\n\n\n\x03\x04\x01\x01\x12\x03:\x08\x0f\n\ + \xe0\x01\n\x04\x04\x01\x02\0\x12\x03?\x02\x12\x1a\xd2\x01\x20A\x20perman\ + ent\x20unique\x20identifier\x20for\x20the\x20cluster.\x20For\x20technica\ + l\x20reasons,\x20the\n\x20zone\x20in\x20which\x20the\x20cluster\x20resid\ + es\x20is\x20included\x20here.\n\x20Values\x20are\x20of\x20the\x20form\n\ + \x20projects//zones//clusters/[a-z][-a-z0-9]*\n\n\r\n\x05\ + \x04\x01\x02\0\x04\x12\x04?\x02:\x11\n\x0c\n\x05\x04\x01\x02\0\x05\x12\ + \x03?\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03?\t\r\n\x0c\n\x05\x04\ + \x01\x02\0\x03\x12\x03?\x10\x11\n\xf5\x01\n\x04\x04\x01\x02\x01\x12\x03E\ + \x025\x1a\xe7\x01\x20The\x20operation\x20currently\x20running\x20on\x20t\ + he\x20cluster,\x20if\x20any.\n\x20This\x20cannot\x20be\x20set\x20directl\ + y,\x20only\x20through\x20CreateCluster,\x20UpdateCluster,\n\x20or\x20Und\ + eleteCluster.\x20Calls\x20to\x20these\x20methods\x20will\x20be\x20reject\ + ed\x20if\n\x20\"current_operation\"\x20is\x20already\x20set.\n\n\r\n\x05\ + \x04\x01\x02\x01\x04\x12\x04E\x02?\x12\n\x0c\n\x05\x04\x01\x02\x01\x06\ + \x12\x03E\x02\x1e\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03E\x1f0\n\x0c\n\ + \x05\x04\x01\x02\x01\x03\x12\x03E34\nd\n\x04\x04\x01\x02\x02\x12\x03I\ + \x02\x1a\x1aW\x20The\x20descriptive\x20name\x20for\x20this\x20cluster\ + \x20as\x20it\x20appears\x20in\x20UIs.\n\x20Must\x20be\x20unique\x20per\ + \x20zone.\n\n\r\n\x05\x04\x01\x02\x02\x04\x12\x04I\x02E5\n\x0c\n\x05\x04\ + \x01\x02\x02\x05\x12\x03I\x02\x08\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\ + \x03I\t\x15\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03I\x18\x19\nC\n\x04\ + \x04\x01\x02\x03\x12\x03L\x02\x18\x1a6\x20The\x20number\x20of\x20serve\ + \x20nodes\x20allocated\x20to\x20this\x20cluster.\n\n\r\n\x05\x04\x01\x02\ + \x03\x04\x12\x04L\x02I\x1a\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03L\x02\ + \x07\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03L\x08\x13\n\x0c\n\x05\x04\ + \x01\x02\x03\x03\x12\x03L\x16\x17\n\x9b\x01\n\x04\x04\x01\x02\x04\x12\ + \x03P\x02'\x1a\x8d\x01\x20What\x20storage\x20type\x20to\x20use\x20for\ + \x20tables\x20in\x20this\x20cluster.\x20Only\x20configurable\x20at\n\x20\ + cluster\x20creation\x20time.\x20If\x20unspecified,\x20STORAGE_SSD\x20wil\ + l\x20be\x20used.\n\n\r\n\x05\x04\x01\x02\x04\x04\x12\x04P\x02L\x18\n\x0c\ + \n\x05\x04\x01\x02\x04\x06\x12\x03P\x02\r\n\x0c\n\x05\x04\x01\x02\x04\ + \x01\x12\x03P\x0e\"\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03P%&\n\n\n\x02\ + \x05\0\x12\x04S\0]\x01\n\n\n\x03\x05\0\x01\x12\x03S\x05\x10\n4\n\x04\x05\ + \0\x02\0\x12\x03U\x02\x1a\x1a'\x20The\x20storage\x20type\x20used\x20is\ + \x20unspecified.\n\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03U\x02\x15\n\x0c\n\ + \x05\x05\0\x02\0\x02\x12\x03U\x18\x19\nR\n\x04\x05\0\x02\x01\x12\x03X\ + \x02\x12\x1aE\x20Data\x20will\x20be\x20stored\x20in\x20SSD,\x20providing\ + \x20low\x20and\x20consistent\x20latencies.\n\n\x0c\n\x05\x05\0\x02\x01\ + \x01\x12\x03X\x02\r\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03X\x10\x11\nZ\n\ + \x04\x05\0\x02\x02\x12\x03\\\x02\x12\x1aM\x20Data\x20will\x20be\x20store\ + d\x20in\x20HDD,\x20providing\x20high\x20and\x20less\x20predictable\n\x20\ + latencies.\n\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\\\x02\r\n\x0c\n\x05\ + \x05\0\x02\x02\x02\x12\x03\\\x10\x11b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service.rs new file mode 100644 index 00000000..e9acc350 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service.rs @@ -0,0 +1,212 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n?google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto\x12\ + \x20google.bigtable.admin.cluster.v1\x1a\x1cgoogle/api/annotations.proto\ + \x1a = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_grpc.rs new file mode 100644 index 00000000..0e458055 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_grpc.rs @@ -0,0 +1,239 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_ZONES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_GET_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_CLUSTERS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_CREATE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_UPDATE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_DELETE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CLUSTER_SERVICE_UNDELETE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableClusterServiceClient { + client: ::grpcio::Client, +} + +impl BigtableClusterServiceClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableClusterServiceClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn list_zones_opt(&self, req: &super::bigtable_cluster_service_messages::ListZonesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_ZONES, req, opt) + } + + pub fn list_zones(&self, req: &super::bigtable_cluster_service_messages::ListZonesRequest) -> ::grpcio::Result { + self.list_zones_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_zones_async_opt(&self, req: &super::bigtable_cluster_service_messages::ListZonesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_ZONES, req, opt) + } + + pub fn list_zones_async(&self, req: &super::bigtable_cluster_service_messages::ListZonesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_zones_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_cluster_opt(&self, req: &super::bigtable_cluster_service_messages::GetClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_GET_CLUSTER, req, opt) + } + + pub fn get_cluster(&self, req: &super::bigtable_cluster_service_messages::GetClusterRequest) -> ::grpcio::Result { + self.get_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_cluster_async_opt(&self, req: &super::bigtable_cluster_service_messages::GetClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_GET_CLUSTER, req, opt) + } + + pub fn get_cluster_async(&self, req: &super::bigtable_cluster_service_messages::GetClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_clusters_opt(&self, req: &super::bigtable_cluster_service_messages::ListClustersRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_CLUSTERS, req, opt) + } + + pub fn list_clusters(&self, req: &super::bigtable_cluster_service_messages::ListClustersRequest) -> ::grpcio::Result { + self.list_clusters_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_clusters_async_opt(&self, req: &super::bigtable_cluster_service_messages::ListClustersRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_CLUSTERS, req, opt) + } + + pub fn list_clusters_async(&self, req: &super::bigtable_cluster_service_messages::ListClustersRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_clusters_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_cluster_opt(&self, req: &super::bigtable_cluster_service_messages::CreateClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_CREATE_CLUSTER, req, opt) + } + + pub fn create_cluster(&self, req: &super::bigtable_cluster_service_messages::CreateClusterRequest) -> ::grpcio::Result { + self.create_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_cluster_async_opt(&self, req: &super::bigtable_cluster_service_messages::CreateClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_CREATE_CLUSTER, req, opt) + } + + pub fn create_cluster_async(&self, req: &super::bigtable_cluster_service_messages::CreateClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_cluster_opt(&self, req: &super::bigtable_cluster_data::Cluster, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_UPDATE_CLUSTER, req, opt) + } + + pub fn update_cluster(&self, req: &super::bigtable_cluster_data::Cluster) -> ::grpcio::Result { + self.update_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_cluster_async_opt(&self, req: &super::bigtable_cluster_data::Cluster, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_UPDATE_CLUSTER, req, opt) + } + + pub fn update_cluster_async(&self, req: &super::bigtable_cluster_data::Cluster) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_cluster_opt(&self, req: &super::bigtable_cluster_service_messages::DeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_DELETE_CLUSTER, req, opt) + } + + pub fn delete_cluster(&self, req: &super::bigtable_cluster_service_messages::DeleteClusterRequest) -> ::grpcio::Result { + self.delete_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_cluster_async_opt(&self, req: &super::bigtable_cluster_service_messages::DeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_DELETE_CLUSTER, req, opt) + } + + pub fn delete_cluster_async(&self, req: &super::bigtable_cluster_service_messages::DeleteClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn undelete_cluster_opt(&self, req: &super::bigtable_cluster_service_messages::UndeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CLUSTER_SERVICE_UNDELETE_CLUSTER, req, opt) + } + + pub fn undelete_cluster(&self, req: &super::bigtable_cluster_service_messages::UndeleteClusterRequest) -> ::grpcio::Result { + self.undelete_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn undelete_cluster_async_opt(&self, req: &super::bigtable_cluster_service_messages::UndeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CLUSTER_SERVICE_UNDELETE_CLUSTER, req, opt) + } + + pub fn undelete_cluster_async(&self, req: &super::bigtable_cluster_service_messages::UndeleteClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.undelete_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait BigtableClusterService { + fn list_zones(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::ListZonesRequest, sink: ::grpcio::UnarySink); + fn get_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::GetClusterRequest, sink: ::grpcio::UnarySink); + fn list_clusters(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::ListClustersRequest, sink: ::grpcio::UnarySink); + fn create_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::CreateClusterRequest, sink: ::grpcio::UnarySink); + fn update_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_data::Cluster, sink: ::grpcio::UnarySink); + fn delete_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::DeleteClusterRequest, sink: ::grpcio::UnarySink); + fn undelete_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_cluster_service_messages::UndeleteClusterRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable_cluster_service(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_ZONES, move |ctx, req, resp| { + instance.list_zones(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_GET_CLUSTER, move |ctx, req, resp| { + instance.get_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_LIST_CLUSTERS, move |ctx, req, resp| { + instance.list_clusters(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_CREATE_CLUSTER, move |ctx, req, resp| { + instance.create_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_UPDATE_CLUSTER, move |ctx, req, resp| { + instance.update_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_DELETE_CLUSTER, move |ctx, req, resp| { + instance.delete_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CLUSTER_SERVICE_UNDELETE_CLUSTER, move |ctx, req, resp| { + instance.undelete_cluster(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.rs new file mode 100644 index 00000000..2b870d44 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.rs @@ -0,0 +1,2765 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct ListZonesRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListZonesRequest { + fn default() -> &'a ListZonesRequest { + ::default_instance() + } +} + +impl ListZonesRequest { + pub fn new() -> ListZonesRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListZonesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListZonesRequest { + ListZonesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ListZonesRequest| { &m.name }, + |m: &mut ListZonesRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListZonesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListZonesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListZonesRequest, + }; + unsafe { + instance.get(ListZonesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListZonesRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListZonesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListZonesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListZonesResponse { + // message fields + pub zones: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListZonesResponse { + fn default() -> &'a ListZonesResponse { + ::default_instance() + } +} + +impl ListZonesResponse { + pub fn new() -> ListZonesResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.cluster.v1.Zone zones = 1; + + + pub fn get_zones(&self) -> &[super::bigtable_cluster_data::Zone] { + &self.zones + } + pub fn clear_zones(&mut self) { + self.zones.clear(); + } + + // Param is passed by value, moved + pub fn set_zones(&mut self, v: ::protobuf::RepeatedField) { + self.zones = v; + } + + // Mutable pointer to the field. + pub fn mut_zones(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.zones + } + + // Take field + pub fn take_zones(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.zones, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ListZonesResponse { + fn is_initialized(&self) -> bool { + for v in &self.zones { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.zones)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.zones { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.zones { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListZonesResponse { + ListZonesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "zones", + |m: &ListZonesResponse| { &m.zones }, + |m: &mut ListZonesResponse| { &mut m.zones }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListZonesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListZonesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListZonesResponse, + }; + unsafe { + instance.get(ListZonesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListZonesResponse { + fn clear(&mut self) { + self.zones.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListZonesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListZonesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetClusterRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetClusterRequest { + fn default() -> &'a GetClusterRequest { + ::default_instance() + } +} + +impl GetClusterRequest { + pub fn new() -> GetClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetClusterRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetClusterRequest { + GetClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetClusterRequest| { &m.name }, + |m: &mut GetClusterRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetClusterRequest, + }; + unsafe { + instance.get(GetClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for GetClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListClustersRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListClustersRequest { + fn default() -> &'a ListClustersRequest { + ::default_instance() + } +} + +impl ListClustersRequest { + pub fn new() -> ListClustersRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListClustersRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListClustersRequest { + ListClustersRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ListClustersRequest| { &m.name }, + |m: &mut ListClustersRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListClustersRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListClustersRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListClustersRequest, + }; + unsafe { + instance.get(ListClustersRequest::new) + } + } +} + +impl ::protobuf::Clear for ListClustersRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListClustersRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListClustersRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListClustersResponse { + // message fields + pub clusters: ::protobuf::RepeatedField, + pub failed_zones: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListClustersResponse { + fn default() -> &'a ListClustersResponse { + ::default_instance() + } +} + +impl ListClustersResponse { + pub fn new() -> ListClustersResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.cluster.v1.Cluster clusters = 1; + + + pub fn get_clusters(&self) -> &[super::bigtable_cluster_data::Cluster] { + &self.clusters + } + pub fn clear_clusters(&mut self) { + self.clusters.clear(); + } + + // Param is passed by value, moved + pub fn set_clusters(&mut self, v: ::protobuf::RepeatedField) { + self.clusters = v; + } + + // Mutable pointer to the field. + pub fn mut_clusters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.clusters + } + + // Take field + pub fn take_clusters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.clusters, ::protobuf::RepeatedField::new()) + } + + // repeated .google.bigtable.admin.cluster.v1.Zone failed_zones = 2; + + + pub fn get_failed_zones(&self) -> &[super::bigtable_cluster_data::Zone] { + &self.failed_zones + } + pub fn clear_failed_zones(&mut self) { + self.failed_zones.clear(); + } + + // Param is passed by value, moved + pub fn set_failed_zones(&mut self, v: ::protobuf::RepeatedField) { + self.failed_zones = v; + } + + // Mutable pointer to the field. + pub fn mut_failed_zones(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.failed_zones + } + + // Take field + pub fn take_failed_zones(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.failed_zones, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ListClustersResponse { + fn is_initialized(&self) -> bool { + for v in &self.clusters { + if !v.is_initialized() { + return false; + } + }; + for v in &self.failed_zones { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.clusters)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.failed_zones)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.clusters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.failed_zones { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.clusters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.failed_zones { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListClustersResponse { + ListClustersResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "clusters", + |m: &ListClustersResponse| { &m.clusters }, + |m: &mut ListClustersResponse| { &mut m.clusters }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "failed_zones", + |m: &ListClustersResponse| { &m.failed_zones }, + |m: &mut ListClustersResponse| { &mut m.failed_zones }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListClustersResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListClustersResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListClustersResponse, + }; + unsafe { + instance.get(ListClustersResponse::new) + } + } +} + +impl ::protobuf::Clear for ListClustersResponse { + fn clear(&mut self) { + self.clusters.clear(); + self.failed_zones.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListClustersResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListClustersResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateClusterRequest { + // message fields + pub name: ::std::string::String, + pub cluster_id: ::std::string::String, + pub cluster: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateClusterRequest { + fn default() -> &'a CreateClusterRequest { + ::default_instance() + } +} + +impl CreateClusterRequest { + pub fn new() -> CreateClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string cluster_id = 2; + + + pub fn get_cluster_id(&self) -> &str { + &self.cluster_id + } + pub fn clear_cluster_id(&mut self) { + self.cluster_id.clear(); + } + + // Param is passed by value, moved + pub fn set_cluster_id(&mut self, v: ::std::string::String) { + self.cluster_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster_id(&mut self) -> &mut ::std::string::String { + &mut self.cluster_id + } + + // Take field + pub fn take_cluster_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.cluster_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.cluster.v1.Cluster cluster = 3; + + + pub fn get_cluster(&self) -> &super::bigtable_cluster_data::Cluster { + self.cluster.as_ref().unwrap_or_else(|| super::bigtable_cluster_data::Cluster::default_instance()) + } + pub fn clear_cluster(&mut self) { + self.cluster.clear(); + } + + pub fn has_cluster(&self) -> bool { + self.cluster.is_some() + } + + // Param is passed by value, moved + pub fn set_cluster(&mut self, v: super::bigtable_cluster_data::Cluster) { + self.cluster = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster(&mut self) -> &mut super::bigtable_cluster_data::Cluster { + if self.cluster.is_none() { + self.cluster.set_default(); + } + self.cluster.as_mut().unwrap() + } + + // Take field + pub fn take_cluster(&mut self) -> super::bigtable_cluster_data::Cluster { + self.cluster.take().unwrap_or_else(|| super::bigtable_cluster_data::Cluster::new()) + } +} + +impl ::protobuf::Message for CreateClusterRequest { + fn is_initialized(&self) -> bool { + for v in &self.cluster { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cluster_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cluster)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.cluster_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.cluster_id); + } + if let Some(ref v) = self.cluster.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.cluster_id.is_empty() { + os.write_string(2, &self.cluster_id)?; + } + if let Some(ref v) = self.cluster.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateClusterRequest { + CreateClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CreateClusterRequest| { &m.name }, + |m: &mut CreateClusterRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "cluster_id", + |m: &CreateClusterRequest| { &m.cluster_id }, + |m: &mut CreateClusterRequest| { &mut m.cluster_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "cluster", + |m: &CreateClusterRequest| { &m.cluster }, + |m: &mut CreateClusterRequest| { &mut m.cluster }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateClusterRequest, + }; + unsafe { + instance.get(CreateClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.cluster_id.clear(); + self.cluster.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateClusterMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateClusterMetadata { + fn default() -> &'a CreateClusterMetadata { + ::default_instance() + } +} + +impl CreateClusterMetadata { + pub fn new() -> CreateClusterMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.cluster.v1.CreateClusterRequest original_request = 1; + + + pub fn get_original_request(&self) -> &CreateClusterRequest { + self.original_request.as_ref().unwrap_or_else(|| CreateClusterRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: CreateClusterRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut CreateClusterRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> CreateClusterRequest { + self.original_request.take().unwrap_or_else(|| CreateClusterRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CreateClusterMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateClusterMetadata { + CreateClusterMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &CreateClusterMetadata| { &m.original_request }, + |m: &mut CreateClusterMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &CreateClusterMetadata| { &m.request_time }, + |m: &mut CreateClusterMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &CreateClusterMetadata| { &m.finish_time }, + |m: &mut CreateClusterMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateClusterMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateClusterMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateClusterMetadata, + }; + unsafe { + instance.get(CreateClusterMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateClusterMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateClusterMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateClusterMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateClusterMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub cancel_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateClusterMetadata { + fn default() -> &'a UpdateClusterMetadata { + ::default_instance() + } +} + +impl UpdateClusterMetadata { + pub fn new() -> UpdateClusterMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.cluster.v1.Cluster original_request = 1; + + + pub fn get_original_request(&self) -> &super::bigtable_cluster_data::Cluster { + self.original_request.as_ref().unwrap_or_else(|| super::bigtable_cluster_data::Cluster::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: super::bigtable_cluster_data::Cluster) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut super::bigtable_cluster_data::Cluster { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> super::bigtable_cluster_data::Cluster { + self.original_request.take().unwrap_or_else(|| super::bigtable_cluster_data::Cluster::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp cancel_time = 3; + + + pub fn get_cancel_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.cancel_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_cancel_time(&mut self) { + self.cancel_time.clear(); + } + + pub fn has_cancel_time(&self) -> bool { + self.cancel_time.is_some() + } + + // Param is passed by value, moved + pub fn set_cancel_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.cancel_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cancel_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.cancel_time.is_none() { + self.cancel_time.set_default(); + } + self.cancel_time.as_mut().unwrap() + } + + // Take field + pub fn take_cancel_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.cancel_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 4; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for UpdateClusterMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.cancel_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cancel_time)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.cancel_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.cancel_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateClusterMetadata { + UpdateClusterMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &UpdateClusterMetadata| { &m.original_request }, + |m: &mut UpdateClusterMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &UpdateClusterMetadata| { &m.request_time }, + |m: &mut UpdateClusterMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "cancel_time", + |m: &UpdateClusterMetadata| { &m.cancel_time }, + |m: &mut UpdateClusterMetadata| { &mut m.cancel_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &UpdateClusterMetadata| { &m.finish_time }, + |m: &mut UpdateClusterMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateClusterMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateClusterMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateClusterMetadata, + }; + unsafe { + instance.get(UpdateClusterMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateClusterMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.cancel_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateClusterMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateClusterMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteClusterRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteClusterRequest { + fn default() -> &'a DeleteClusterRequest { + ::default_instance() + } +} + +impl DeleteClusterRequest { + pub fn new() -> DeleteClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteClusterRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteClusterRequest { + DeleteClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteClusterRequest| { &m.name }, + |m: &mut DeleteClusterRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteClusterRequest, + }; + unsafe { + instance.get(DeleteClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UndeleteClusterRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UndeleteClusterRequest { + fn default() -> &'a UndeleteClusterRequest { + ::default_instance() + } +} + +impl UndeleteClusterRequest { + pub fn new() -> UndeleteClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for UndeleteClusterRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UndeleteClusterRequest { + UndeleteClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &UndeleteClusterRequest| { &m.name }, + |m: &mut UndeleteClusterRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UndeleteClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UndeleteClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UndeleteClusterRequest, + }; + unsafe { + instance.get(UndeleteClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for UndeleteClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UndeleteClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UndeleteClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UndeleteClusterMetadata { + // message fields + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UndeleteClusterMetadata { + fn default() -> &'a UndeleteClusterMetadata { + ::default_instance() + } +} + +impl UndeleteClusterMetadata { + pub fn new() -> UndeleteClusterMetadata { + ::std::default::Default::default() + } + + // .google.protobuf.Timestamp request_time = 1; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 2; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for UndeleteClusterMetadata { + fn is_initialized(&self) -> bool { + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UndeleteClusterMetadata { + UndeleteClusterMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &UndeleteClusterMetadata| { &m.request_time }, + |m: &mut UndeleteClusterMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &UndeleteClusterMetadata| { &m.finish_time }, + |m: &mut UndeleteClusterMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UndeleteClusterMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UndeleteClusterMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UndeleteClusterMetadata, + }; + unsafe { + instance.get(UndeleteClusterMetadata::new) + } + } +} + +impl ::protobuf::Clear for UndeleteClusterMetadata { + fn clear(&mut self) { + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UndeleteClusterMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UndeleteClusterMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct V2OperationMetadata { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a V2OperationMetadata { + fn default() -> &'a V2OperationMetadata { + ::default_instance() + } +} + +impl V2OperationMetadata { + pub fn new() -> V2OperationMetadata { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for V2OperationMetadata { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> V2OperationMetadata { + V2OperationMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "V2OperationMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static V2OperationMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const V2OperationMetadata, + }; + unsafe { + instance.get(V2OperationMetadata::new) + } + } +} + +impl ::protobuf::Clear for V2OperationMetadata { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for V2OperationMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for V2OperationMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \nHgoogle/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.pr\ + oto\x12\x20google.bigtable.admin.cluster.v1\x1a\n\n\r\n\ + \x05\x04\0\x02\0\x04\x12\x04\x20\x02\x1c\x1a\n\x0c\n\x05\x04\0\x02\0\x05\ + \x12\x03\x20\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x20\t\r\n\x0c\n\ + \x05\x04\0\x02\0\x03\x12\x03\x20\x10\x11\nD\n\x02\x04\x01\x12\x04$\0'\ + \x01\x1a8\x20Response\x20message\x20for\x20BigtableClusterService.ListZo\ + nes.\n\n\n\n\x03\x04\x01\x01\x12\x03$\x08\x19\n+\n\x04\x04\x01\x02\0\x12\ + \x03&\x02\x1a\x1a\x1e\x20The\x20list\x20of\x20requested\x20zones.\n\n\ + \x0c\n\x05\x04\x01\x02\0\x04\x12\x03&\x02\n\n\x0c\n\x05\x04\x01\x02\0\ + \x06\x12\x03&\x0b\x0f\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03&\x10\x15\n\ + \x0c\n\x05\x04\x01\x02\0\x03\x12\x03&\x18\x19\nD\n\x02\x04\x02\x12\x04*\ + \0.\x01\x1a8\x20Request\x20message\x20for\x20BigtableClusterService.GetC\ + luster.\n\n\n\n\x03\x04\x02\x01\x12\x03*\x08\x19\n\x83\x01\n\x04\x04\x02\ + \x02\0\x12\x03-\x02\x12\x1av\x20The\x20unique\x20name\x20of\x20the\x20re\ + quested\x20cluster.\n\x20Values\x20are\x20of\x20the\x20form\x20projects/\ + /zones//clusters/\n\n\r\n\x05\x04\x02\x02\0\x04\ + \x12\x04-\x02*\x1b\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03-\x02\x08\n\x0c\ + \n\x05\x04\x02\x02\0\x01\x12\x03-\t\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\ + \x03-\x10\x11\nF\n\x02\x04\x03\x12\x041\05\x01\x1a:\x20Request\x20messag\ + e\x20for\x20BigtableClusterService.ListClusters.\n\n\n\n\x03\x04\x03\x01\ + \x12\x031\x08\x1b\n\x83\x01\n\x04\x04\x03\x02\0\x12\x034\x02\x12\x1av\ + \x20The\x20unique\x20name\x20of\x20the\x20project\x20for\x20which\x20a\ + \x20list\x20of\x20clusters\x20is\x20requested.\n\x20Values\x20are\x20of\ + \x20the\x20form\x20projects/\n\n\r\n\x05\x04\x03\x02\0\x04\x12\ + \x044\x021\x1d\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x034\x02\x08\n\x0c\n\ + \x05\x04\x03\x02\0\x01\x12\x034\t\r\n\x0c\n\x05\x04\x03\x02\0\x03\x12\ + \x034\x10\x11\nG\n\x02\x04\x04\x12\x048\0>\x01\x1a;\x20Response\x20messa\ + ge\x20for\x20BigtableClusterService.ListClusters.\n\n\n\n\x03\x04\x04\ + \x01\x12\x038\x08\x1c\n.\n\x04\x04\x04\x02\0\x12\x03:\x02\x20\x1a!\x20Th\ + e\x20list\x20of\x20requested\x20Clusters.\n\n\x0c\n\x05\x04\x04\x02\0\ + \x04\x12\x03:\x02\n\n\x0c\n\x05\x04\x04\x02\0\x06\x12\x03:\x0b\x12\n\x0c\ + \n\x05\x04\x04\x02\0\x01\x12\x03:\x13\x1b\n\x0c\n\x05\x04\x04\x02\0\x03\ + \x12\x03:\x1e\x1f\nC\n\x04\x04\x04\x02\x01\x12\x03=\x02!\x1a6\x20The\x20\ + zones\x20for\x20which\x20clusters\x20could\x20not\x20be\x20retrieved.\n\ + \n\x0c\n\x05\x04\x04\x02\x01\x04\x12\x03=\x02\n\n\x0c\n\x05\x04\x04\x02\ + \x01\x06\x12\x03=\x0b\x0f\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03=\x10\ + \x1c\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03=\x1f\x20\nG\n\x02\x04\x05\ + \x12\x04A\0O\x01\x1a;\x20Request\x20message\x20for\x20BigtableClusterSer\ + vice.CreateCluster.\n\n\n\n\x03\x04\x05\x01\x12\x03A\x08\x1c\n\x82\x01\n\ + \x04\x04\x05\x02\0\x12\x03D\x02\x12\x1au\x20The\x20unique\x20name\x20of\ + \x20the\x20zone\x20in\x20which\x20to\x20create\x20the\x20cluster.\n\x20V\ + alues\x20are\x20of\x20the\x20form\x20projects//zones/\n\n\ + \r\n\x05\x04\x05\x02\0\x04\x12\x04D\x02A\x1e\n\x0c\n\x05\x04\x05\x02\0\ + \x05\x12\x03D\x02\x08\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03D\t\r\n\x0c\n\ + \x05\x04\x05\x02\0\x03\x12\x03D\x10\x11\n\xc5\x01\n\x04\x04\x05\x02\x01\ + \x12\x03I\x02\x18\x1a\xb7\x01\x20The\x20id\x20to\x20be\x20used\x20when\ + \x20referring\x20to\x20the\x20new\x20cluster\x20within\x20its\x20zone,\n\ + \x20e.g.\x20just\x20the\x20\"test-cluster\"\x20section\x20of\x20the\x20f\ + ull\x20name\n\x20\"projects//zones//clusters/test-cluster\ + \".\n\n\r\n\x05\x04\x05\x02\x01\x04\x12\x04I\x02D\x12\n\x0c\n\x05\x04\ + \x05\x02\x01\x05\x12\x03I\x02\x08\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\ + \x03I\t\x13\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03I\x16\x17\nu\n\x04\ + \x04\x05\x02\x02\x12\x03N\x02\x16\x1ah\x20The\x20cluster\x20to\x20create\ + .\n\x20The\x20\"name\",\x20\"delete_time\",\x20and\x20\"current_operatio\ + n\"\x20fields\x20must\x20be\x20left\n\x20blank.\n\n\r\n\x05\x04\x05\x02\ + \x02\x04\x12\x04N\x02I\x18\n\x0c\n\x05\x04\x05\x02\x02\x06\x12\x03N\x02\ + \t\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03N\n\x11\n\x0c\n\x05\x04\x05\ + \x02\x02\x03\x12\x03N\x14\x15\n`\n\x02\x04\x06\x12\x04S\0\\\x01\x1aT\x20\ + Metadata\x20type\x20for\x20the\x20operation\x20returned\x20by\n\x20Bigta\ + bleClusterService.CreateCluster.\n\n\n\n\x03\x04\x06\x01\x12\x03S\x08\ + \x1d\nI\n\x04\x04\x06\x02\0\x12\x03U\x02,\x1a<\x20The\x20request\x20whic\ + h\x20prompted\x20the\x20creation\x20of\x20this\x20operation.\n\n\r\n\x05\ + \x04\x06\x02\0\x04\x12\x04U\x02S\x1f\n\x0c\n\x05\x04\x06\x02\0\x06\x12\ + \x03U\x02\x16\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03U\x17'\n\x0c\n\x05\ + \x04\x06\x02\0\x03\x12\x03U*+\n?\n\x04\x04\x06\x02\x01\x12\x03X\x02-\x1a\ + 2\x20The\x20time\x20at\x20which\x20original_request\x20was\x20received.\ + \n\n\r\n\x05\x04\x06\x02\x01\x04\x12\x04X\x02U,\n\x0c\n\x05\x04\x06\x02\ + \x01\x06\x12\x03X\x02\x1b\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\x03X\x1c(\ + \n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03X+,\nU\n\x04\x04\x06\x02\x02\x12\ + \x03[\x02,\x1aH\x20The\x20time\x20at\x20which\x20this\x20operation\x20fa\ + iled\x20or\x20was\x20completed\x20successfully.\n\n\r\n\x05\x04\x06\x02\ + \x02\x04\x12\x04[\x02X-\n\x0c\n\x05\x04\x06\x02\x02\x06\x12\x03[\x02\x1b\ + \n\x0c\n\x05\x04\x06\x02\x02\x01\x12\x03[\x1c'\n\x0c\n\x05\x04\x06\x02\ + \x02\x03\x12\x03[*+\n`\n\x02\x04\x07\x12\x04`\0n\x01\x1aT\x20Metadata\ + \x20type\x20for\x20the\x20operation\x20returned\x20by\n\x20BigtableClust\ + erService.UpdateCluster.\n\n\n\n\x03\x04\x07\x01\x12\x03`\x08\x1d\nI\n\ + \x04\x04\x07\x02\0\x12\x03b\x02\x1f\x1a<\x20The\x20request\x20which\x20p\ + rompted\x20the\x20creation\x20of\x20this\x20operation.\n\n\r\n\x05\x04\ + \x07\x02\0\x04\x12\x04b\x02`\x1f\n\x0c\n\x05\x04\x07\x02\0\x06\x12\x03b\ + \x02\t\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03b\n\x1a\n\x0c\n\x05\x04\x07\ + \x02\0\x03\x12\x03b\x1d\x1e\n?\n\x04\x04\x07\x02\x01\x12\x03e\x02-\x1a2\ + \x20The\x20time\x20at\x20which\x20original_request\x20was\x20received.\n\ + \n\r\n\x05\x04\x07\x02\x01\x04\x12\x04e\x02b\x1f\n\x0c\n\x05\x04\x07\x02\ + \x01\x06\x12\x03e\x02\x1b\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03e\x1c(\ + \n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03e+,\n\xbc\x01\n\x04\x04\x07\x02\ + \x02\x12\x03j\x02,\x1a\xae\x01\x20The\x20time\x20at\x20which\x20this\x20\ + operation\x20was\x20cancelled.\x20If\x20set,\x20this\x20operation\x20is\ + \n\x20in\x20the\x20process\x20of\x20undoing\x20itself\x20(which\x20is\ + \x20guaranteed\x20to\x20succeed)\x20and\n\x20cannot\x20be\x20cancelled\ + \x20again.\n\n\r\n\x05\x04\x07\x02\x02\x04\x12\x04j\x02e-\n\x0c\n\x05\ + \x04\x07\x02\x02\x06\x12\x03j\x02\x1b\n\x0c\n\x05\x04\x07\x02\x02\x01\ + \x12\x03j\x1c'\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03j*+\nU\n\x04\x04\ + \x07\x02\x03\x12\x03m\x02,\x1aH\x20The\x20time\x20at\x20which\x20this\ + \x20operation\x20failed\x20or\x20was\x20completed\x20successfully.\n\n\r\ + \n\x05\x04\x07\x02\x03\x04\x12\x04m\x02j,\n\x0c\n\x05\x04\x07\x02\x03\ + \x06\x12\x03m\x02\x1b\n\x0c\n\x05\x04\x07\x02\x03\x01\x12\x03m\x1c'\n\ + \x0c\n\x05\x04\x07\x02\x03\x03\x12\x03m*+\nG\n\x02\x04\x08\x12\x04q\0u\ + \x01\x1a;\x20Request\x20message\x20for\x20BigtableClusterService.DeleteC\ + luster.\n\n\n\n\x03\x04\x08\x01\x12\x03q\x08\x1c\n\x87\x01\n\x04\x04\x08\ + \x02\0\x12\x03t\x02\x12\x1az\x20The\x20unique\x20name\x20of\x20the\x20cl\ + uster\x20to\x20be\x20deleted.\n\x20Values\x20are\x20of\x20the\x20form\ + \x20projects//zones//clusters/\n\n\r\n\x05\x04\ + \x08\x02\0\x04\x12\x04t\x02q\x1e\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03t\ + \x02\x08\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03t\t\r\n\x0c\n\x05\x04\x08\ + \x02\0\x03\x12\x03t\x10\x11\nI\n\x02\x04\t\x12\x04x\0|\x01\x1a=\x20Reque\ + st\x20message\x20for\x20BigtableClusterService.UndeleteCluster.\n\n\n\n\ + \x03\x04\t\x01\x12\x03x\x08\x1e\n\x8a\x01\n\x04\x04\t\x02\0\x12\x03{\x02\ + \x12\x1a}\x20The\x20unique\x20name\x20of\x20the\x20cluster\x20to\x20be\ + \x20un-deleted.\n\x20Values\x20are\x20of\x20the\x20form\x20projects//zones//clusters/\n\n\r\n\x05\x04\t\x02\0\x04\x12\ + \x04{\x02x\x20\n\x0c\n\x05\x04\t\x02\0\x05\x12\x03{\x02\x08\n\x0c\n\x05\ + \x04\t\x02\0\x01\x12\x03{\t\r\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03{\x10\ + \x11\nd\n\x02\x04\n\x12\x06\x80\x01\0\x86\x01\x01\x1aV\x20Metadata\x20ty\ + pe\x20for\x20the\x20operation\x20returned\x20by\n\x20BigtableClusterServ\ + ice.UndeleteCluster.\n\n\x0b\n\x03\x04\n\x01\x12\x04\x80\x01\x08\x1f\nD\ + \n\x04\x04\n\x02\0\x12\x04\x82\x01\x02-\x1a6\x20The\x20time\x20at\x20whi\ + ch\x20the\x20original\x20request\x20was\x20received.\n\n\x0f\n\x05\x04\n\ + \x02\0\x04\x12\x06\x82\x01\x02\x80\x01!\n\r\n\x05\x04\n\x02\0\x06\x12\ + \x04\x82\x01\x02\x1b\n\r\n\x05\x04\n\x02\0\x01\x12\x04\x82\x01\x1c(\n\r\ + \n\x05\x04\n\x02\0\x03\x12\x04\x82\x01+,\nV\n\x04\x04\n\x02\x01\x12\x04\ + \x85\x01\x02,\x1aH\x20The\x20time\x20at\x20which\x20this\x20operation\ + \x20failed\x20or\x20was\x20completed\x20successfully.\n\n\x0f\n\x05\x04\ + \n\x02\x01\x04\x12\x06\x85\x01\x02\x82\x01-\n\r\n\x05\x04\n\x02\x01\x06\ + \x12\x04\x85\x01\x02\x1b\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\x85\x01\x1c\ + '\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\x85\x01*+\n\xa4\x01\n\x02\x04\x0b\ + \x12\x06\x8a\x01\0\x8c\x01\x01\x1a\x95\x01\x20Metadata\x20type\x20for\ + \x20operations\x20initiated\x20by\x20the\x20V2\x20BigtableAdmin\x20servi\ + ce.\n\x20More\x20complete\x20information\x20for\x20such\x20operations\ + \x20is\x20available\x20via\x20the\x20V2\x20API.\n\n\x0b\n\x03\x04\x0b\ + \x01\x12\x04\x8a\x01\x08\x1bb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/mod.rs new file mode 100644 index 00000000..c1ff8569 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/cluster/v1/mod.rs @@ -0,0 +1,7 @@ +pub mod bigtable_cluster_data; +pub mod bigtable_cluster_service; +pub mod bigtable_cluster_service_grpc; +pub mod bigtable_cluster_service_messages; + +pub(crate) use crate::empty; +pub(crate) use crate::longrunning::operations; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/mod.rs new file mode 100644 index 00000000..e0bf5b53 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/mod.rs @@ -0,0 +1,3 @@ +pub mod cluster; +pub mod table; +pub mod v2; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/mod.rs new file mode 100644 index 00000000..a3a6d96c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_data.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_data.rs new file mode 100644 index 00000000..a47c3969 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_data.rs @@ -0,0 +1,1589 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/table/v1/bigtable_table_data.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Table { + // message fields + pub name: ::std::string::String, + pub current_operation: ::protobuf::SingularPtrField, + pub column_families: ::std::collections::HashMap<::std::string::String, ColumnFamily>, + pub granularity: Table_TimestampGranularity, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Table { + fn default() -> &'a Table { +
::default_instance() + } +} + +impl Table { + pub fn new() -> Table { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.longrunning.Operation current_operation = 2; + + + pub fn get_current_operation(&self) -> &super::operations::Operation { + self.current_operation.as_ref().unwrap_or_else(|| super::operations::Operation::default_instance()) + } + pub fn clear_current_operation(&mut self) { + self.current_operation.clear(); + } + + pub fn has_current_operation(&self) -> bool { + self.current_operation.is_some() + } + + // Param is passed by value, moved + pub fn set_current_operation(&mut self, v: super::operations::Operation) { + self.current_operation = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_current_operation(&mut self) -> &mut super::operations::Operation { + if self.current_operation.is_none() { + self.current_operation.set_default(); + } + self.current_operation.as_mut().unwrap() + } + + // Take field + pub fn take_current_operation(&mut self) -> super::operations::Operation { + self.current_operation.take().unwrap_or_else(|| super::operations::Operation::new()) + } + + // repeated .google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry column_families = 3; + + + pub fn get_column_families(&self) -> &::std::collections::HashMap<::std::string::String, ColumnFamily> { + &self.column_families + } + pub fn clear_column_families(&mut self) { + self.column_families.clear(); + } + + // Param is passed by value, moved + pub fn set_column_families(&mut self, v: ::std::collections::HashMap<::std::string::String, ColumnFamily>) { + self.column_families = v; + } + + // Mutable pointer to the field. + pub fn mut_column_families(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ColumnFamily> { + &mut self.column_families + } + + // Take field + pub fn take_column_families(&mut self) -> ::std::collections::HashMap<::std::string::String, ColumnFamily> { + ::std::mem::replace(&mut self.column_families, ::std::collections::HashMap::new()) + } + + // .google.bigtable.admin.table.v1.Table.TimestampGranularity granularity = 4; + + + pub fn get_granularity(&self) -> Table_TimestampGranularity { + self.granularity + } + pub fn clear_granularity(&mut self) { + self.granularity = Table_TimestampGranularity::MILLIS; + } + + // Param is passed by value, moved + pub fn set_granularity(&mut self, v: Table_TimestampGranularity) { + self.granularity = v; + } +} + +impl ::protobuf::Message for Table { + fn is_initialized(&self) -> bool { + for v in &self.current_operation { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.current_operation)?; + }, + 3 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.column_families)?; + }, + 4 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.granularity, 4, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.current_operation.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(3, &self.column_families); + if self.granularity != Table_TimestampGranularity::MILLIS { + my_size += ::protobuf::rt::enum_size(4, self.granularity); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.current_operation.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(3, &self.column_families, os)?; + if self.granularity != Table_TimestampGranularity::MILLIS { + os.write_enum(4, self.granularity.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Table { + Table::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Table| { &m.name }, + |m: &mut Table| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "current_operation", + |m: &Table| { &m.current_operation }, + |m: &mut Table| { &mut m.current_operation }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "column_families", + |m: &Table| { &m.column_families }, + |m: &mut Table| { &mut m.column_families }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "granularity", + |m: &Table| { &m.granularity }, + |m: &mut Table| { &mut m.granularity }, + )); + ::protobuf::reflect::MessageDescriptor::new::
( + "Table", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Table { + static mut instance: ::protobuf::lazy::Lazy
= ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Table, + }; + unsafe { + instance.get(Table::new) + } + } +} + +impl ::protobuf::Clear for Table { + fn clear(&mut self) { + self.name.clear(); + self.current_operation.clear(); + self.column_families.clear(); + self.granularity = Table_TimestampGranularity::MILLIS; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Table { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Table { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Table_TimestampGranularity { + MILLIS = 0, +} + +impl ::protobuf::ProtobufEnum for Table_TimestampGranularity { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Table_TimestampGranularity::MILLIS), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Table_TimestampGranularity] = &[ + Table_TimestampGranularity::MILLIS, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Table_TimestampGranularity", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Table_TimestampGranularity { +} + +impl ::std::default::Default for Table_TimestampGranularity { + fn default() -> Self { + Table_TimestampGranularity::MILLIS + } +} + +impl ::protobuf::reflect::ProtobufValue for Table_TimestampGranularity { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ColumnFamily { + // message fields + pub name: ::std::string::String, + pub gc_expression: ::std::string::String, + pub gc_rule: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ColumnFamily { + fn default() -> &'a ColumnFamily { + ::default_instance() + } +} + +impl ColumnFamily { + pub fn new() -> ColumnFamily { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string gc_expression = 2; + + + pub fn get_gc_expression(&self) -> &str { + &self.gc_expression + } + pub fn clear_gc_expression(&mut self) { + self.gc_expression.clear(); + } + + // Param is passed by value, moved + pub fn set_gc_expression(&mut self, v: ::std::string::String) { + self.gc_expression = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gc_expression(&mut self) -> &mut ::std::string::String { + &mut self.gc_expression + } + + // Take field + pub fn take_gc_expression(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.gc_expression, ::std::string::String::new()) + } + + // .google.bigtable.admin.table.v1.GcRule gc_rule = 3; + + + pub fn get_gc_rule(&self) -> &GcRule { + self.gc_rule.as_ref().unwrap_or_else(|| GcRule::default_instance()) + } + pub fn clear_gc_rule(&mut self) { + self.gc_rule.clear(); + } + + pub fn has_gc_rule(&self) -> bool { + self.gc_rule.is_some() + } + + // Param is passed by value, moved + pub fn set_gc_rule(&mut self, v: GcRule) { + self.gc_rule = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gc_rule(&mut self) -> &mut GcRule { + if self.gc_rule.is_none() { + self.gc_rule.set_default(); + } + self.gc_rule.as_mut().unwrap() + } + + // Take field + pub fn take_gc_rule(&mut self) -> GcRule { + self.gc_rule.take().unwrap_or_else(|| GcRule::new()) + } +} + +impl ::protobuf::Message for ColumnFamily { + fn is_initialized(&self) -> bool { + for v in &self.gc_rule { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.gc_expression)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.gc_rule)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.gc_expression.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.gc_expression); + } + if let Some(ref v) = self.gc_rule.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.gc_expression.is_empty() { + os.write_string(2, &self.gc_expression)?; + } + if let Some(ref v) = self.gc_rule.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ColumnFamily { + ColumnFamily::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ColumnFamily| { &m.name }, + |m: &mut ColumnFamily| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "gc_expression", + |m: &ColumnFamily| { &m.gc_expression }, + |m: &mut ColumnFamily| { &mut m.gc_expression }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "gc_rule", + |m: &ColumnFamily| { &m.gc_rule }, + |m: &mut ColumnFamily| { &mut m.gc_rule }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ColumnFamily", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ColumnFamily { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ColumnFamily, + }; + unsafe { + instance.get(ColumnFamily::new) + } + } +} + +impl ::protobuf::Clear for ColumnFamily { + fn clear(&mut self) { + self.name.clear(); + self.gc_expression.clear(); + self.gc_rule.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ColumnFamily { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ColumnFamily { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule { + // message oneof groups + pub rule: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule { + fn default() -> &'a GcRule { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum GcRule_oneof_rule { + max_num_versions(i32), + max_age(::protobuf::well_known_types::Duration), + intersection(GcRule_Intersection), + union(GcRule_Union), +} + +impl GcRule { + pub fn new() -> GcRule { + ::std::default::Default::default() + } + + // int32 max_num_versions = 1; + + + pub fn get_max_num_versions(&self) -> i32 { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(v)) => v, + _ => 0, + } + } + pub fn clear_max_num_versions(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_max_num_versions(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_max_num_versions(&mut self, v: i32) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(v)) + } + + // .google.protobuf.Duration max_age = 2; + + + pub fn get_max_age(&self) -> &::protobuf::well_known_types::Duration { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(ref v)) => v, + _ => ::protobuf::well_known_types::Duration::default_instance(), + } + } + pub fn clear_max_age(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_max_age(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_max_age(&mut self, v: ::protobuf::well_known_types::Duration) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(v)) + } + + // Mutable pointer to the field. + pub fn mut_max_age(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if let ::std::option::Option::Some(GcRule_oneof_rule::max_age(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(::protobuf::well_known_types::Duration::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_max_age(&mut self) -> ::protobuf::well_known_types::Duration { + if self.has_max_age() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Duration::new() + } + } + + // .google.bigtable.admin.table.v1.GcRule.Intersection intersection = 3; + + + pub fn get_intersection(&self) -> &GcRule_Intersection { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(ref v)) => v, + _ => GcRule_Intersection::default_instance(), + } + } + pub fn clear_intersection(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_intersection(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_intersection(&mut self, v: GcRule_Intersection) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(v)) + } + + // Mutable pointer to the field. + pub fn mut_intersection(&mut self) -> &mut GcRule_Intersection { + if let ::std::option::Option::Some(GcRule_oneof_rule::intersection(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(GcRule_Intersection::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_intersection(&mut self) -> GcRule_Intersection { + if self.has_intersection() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(v)) => v, + _ => panic!(), + } + } else { + GcRule_Intersection::new() + } + } + + // .google.bigtable.admin.table.v1.GcRule.Union union = 4; + + + pub fn get_union(&self) -> &GcRule_Union { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(ref v)) => v, + _ => GcRule_Union::default_instance(), + } + } + pub fn clear_union(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_union(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_union(&mut self, v: GcRule_Union) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(v)) + } + + // Mutable pointer to the field. + pub fn mut_union(&mut self) -> &mut GcRule_Union { + if let ::std::option::Option::Some(GcRule_oneof_rule::union(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(GcRule_Union::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_union(&mut self) -> GcRule_Union { + if self.has_union() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::union(v)) => v, + _ => panic!(), + } + } else { + GcRule_Union::new() + } + } +} + +impl ::protobuf::Message for GcRule { + fn is_initialized(&self) -> bool { + if let Some(GcRule_oneof_rule::max_age(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + if let Some(GcRule_oneof_rule::intersection(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + if let Some(GcRule_oneof_rule::union(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(is.read_int32()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &GcRule_oneof_rule::max_num_versions(v) => { + my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); + }, + &GcRule_oneof_rule::max_age(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &GcRule_oneof_rule::intersection(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &GcRule_oneof_rule::union(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &GcRule_oneof_rule::max_num_versions(v) => { + os.write_int32(1, v)?; + }, + &GcRule_oneof_rule::max_age(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &GcRule_oneof_rule::intersection(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &GcRule_oneof_rule::union(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule { + GcRule::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "max_num_versions", + GcRule::has_max_num_versions, + GcRule::get_max_num_versions, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>( + "max_age", + GcRule::has_max_age, + GcRule::get_max_age, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, GcRule_Intersection>( + "intersection", + GcRule::has_intersection, + GcRule::get_intersection, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, GcRule_Union>( + "union", + GcRule::has_union, + GcRule::get_union, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule, + }; + unsafe { + instance.get(GcRule::new) + } + } +} + +impl ::protobuf::Clear for GcRule { + fn clear(&mut self) { + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule_Intersection { + // message fields + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule_Intersection { + fn default() -> &'a GcRule_Intersection { + ::default_instance() + } +} + +impl GcRule_Intersection { + pub fn new() -> GcRule_Intersection { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.table.v1.GcRule rules = 1; + + + pub fn get_rules(&self) -> &[GcRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GcRule_Intersection { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.rules { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule_Intersection { + GcRule_Intersection::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &GcRule_Intersection| { &m.rules }, + |m: &mut GcRule_Intersection| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule_Intersection", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule_Intersection { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule_Intersection, + }; + unsafe { + instance.get(GcRule_Intersection::new) + } + } +} + +impl ::protobuf::Clear for GcRule_Intersection { + fn clear(&mut self) { + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule_Intersection { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule_Intersection { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule_Union { + // message fields + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule_Union { + fn default() -> &'a GcRule_Union { + ::default_instance() + } +} + +impl GcRule_Union { + pub fn new() -> GcRule_Union { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.table.v1.GcRule rules = 1; + + + pub fn get_rules(&self) -> &[GcRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GcRule_Union { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.rules { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule_Union { + GcRule_Union::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &GcRule_Union| { &m.rules }, + |m: &mut GcRule_Union| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule_Union", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule_Union { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule_Union, + }; + unsafe { + instance.get(GcRule_Union::new) + } + } +} + +impl ::protobuf::Clear for GcRule_Union { + fn clear(&mut self) { + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule_Union { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule_Union { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n8google/bigtable/admin/table/v1/bigtable_table_data.proto\x12\x1egoogl\ + e.bigtable.admin.table.v1\x1a#google/longrunning/operations.proto\x1a\ + \x1egoogle/protobuf/duration.proto\"\xbe\x03\n\x05Table\x12\x12\n\x04nam\ + e\x18\x01\x20\x01(\tR\x04name\x12J\n\x11current_operation\x18\x02\x20\ + \x01(\x0b2\x1d.google.longrunning.OperationR\x10currentOperation\x12b\n\ + \x0fcolumn_families\x18\x03\x20\x03(\x0b29.google.bigtable.admin.table.v\ + 1.Table.ColumnFamiliesEntryR\x0ecolumnFamilies\x12\\\n\x0bgranularity\ + \x18\x04\x20\x01(\x0e2:.google.bigtable.admin.table.v1.Table.TimestampGr\ + anularityR\x0bgranularity\x1ao\n\x13ColumnFamiliesEntry\x12\x10\n\x03key\ + \x18\x01\x20\x01(\tR\x03key\x12B\n\x05value\x18\x02\x20\x01(\x0b2,.googl\ + e.bigtable.admin.table.v1.ColumnFamilyR\x05value:\x028\x01\"\"\n\x14Time\ + stampGranularity\x12\n\n\x06MILLIS\x10\0\"\x88\x01\n\x0cColumnFamily\x12\ + \x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12#\n\rgc_expression\x18\x02\ + \x20\x01(\tR\x0cgcExpression\x12?\n\x07gc_rule\x18\x03\x20\x01(\x0b2&.go\ + ogle.bigtable.admin.table.v1.GcRuleR\x06gcRule\"\xa8\x03\n\x06GcRule\x12\ + *\n\x10max_num_versions\x18\x01\x20\x01(\x05H\0R\x0emaxNumVersions\x124\ + \n\x07max_age\x18\x02\x20\x01(\x0b2\x19.google.protobuf.DurationH\0R\x06\ + maxAge\x12Y\n\x0cintersection\x18\x03\x20\x01(\x0b23.google.bigtable.adm\ + in.table.v1.GcRule.IntersectionH\0R\x0cintersection\x12D\n\x05union\x18\ + \x04\x20\x01(\x0b2,.google.bigtable.admin.table.v1.GcRule.UnionH\0R\x05u\ + nion\x1aL\n\x0cIntersection\x12<\n\x05rules\x18\x01\x20\x03(\x0b2&.googl\ + e.bigtable.admin.table.v1.GcRuleR\x05rules\x1aE\n\x05Union\x12<\n\x05rul\ + es\x18\x01\x20\x03(\x0b2&.google.bigtable.admin.table.v1.GcRuleR\x05rule\ + sB\x06\n\x04ruleB\x83\x01\n\"com.google.bigtable.admin.table.v1B\x16Bigt\ + ableTableDataProtoP\x01ZCgoogle.golang.org/genproto/googleapis/bigtable/\ + admin/table/v1;tableJ\x80&\n\x06\x12\x04\x0e\0}\x01\n\xbd\x04\n\x01\x0c\ + \x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202017\x20Google\x20Inc.\n\n\ + \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\ + (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\ + xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\ + obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\ + \x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\ + \x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\ + oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\ + \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\ + \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\ + ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\ + governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\ + nse.\n\n\x08\n\x01\x02\x12\x03\x10\0'\n\t\n\x02\x03\0\x12\x03\x12\0-\n\t\ + \n\x02\x03\x01\x12\x03\x13\0(\n\x08\n\x01\x08\x12\x03\x15\0Z\n\t\n\x02\ + \x08\x0b\x12\x03\x15\0Z\n\x08\n\x01\x08\x12\x03\x16\0\"\n\t\n\x02\x08\n\ + \x12\x03\x16\0\"\n\x08\n\x01\x08\x12\x03\x17\07\n\t\n\x02\x08\x08\x12\ + \x03\x17\07\n\x08\n\x01\x08\x12\x03\x18\0;\n\t\n\x02\x08\x01\x12\x03\x18\ + \0;\n\x90\x01\n\x02\x04\0\x12\x04\x1d\02\x01\x1a\x83\x01\x20A\x20collect\ + ion\x20of\x20user\x20data\x20indexed\x20by\x20row,\x20column,\x20and\x20\ + timestamp.\n\x20Each\x20table\x20is\x20served\x20using\x20the\x20resourc\ + es\x20of\x20its\x20parent\x20cluster.\n\n\n\n\x03\x04\0\x01\x12\x03\x1d\ + \x08\r\n\x0c\n\x04\x04\0\x04\0\x12\x04\x1e\x02\x20\x03\n\x0c\n\x05\x04\0\ + \x04\0\x01\x12\x03\x1e\x07\x1b\n\r\n\x06\x04\0\x04\0\x02\0\x12\x03\x1f\ + \x04\x0f\n\x0e\n\x07\x04\0\x04\0\x02\0\x01\x12\x03\x1f\x04\n\n\x0e\n\x07\ + \x04\0\x04\0\x02\0\x02\x12\x03\x1f\r\x0e\na\n\x04\x04\0\x02\0\x12\x03$\ + \x02\x12\x1aT\x20A\x20unique\x20identifier\x20of\x20the\x20form\n\x20/tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*\n\n\r\n\x05\x04\0\x02\0\ + \x04\x12\x04$\x02\x20\x03\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03$\x02\x08\n\ + \x0c\n\x05\x04\0\x02\0\x01\x12\x03$\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\ + \x03$\x10\x11\n\xd5\x01\n\x04\x04\0\x02\x01\x12\x03)\x025\x1a\xc7\x01\ + \x20If\x20this\x20Table\x20is\x20in\x20the\x20process\x20of\x20being\x20\ + created,\x20the\x20Operation\x20used\x20to\n\x20track\x20its\x20progress\ + .\x20As\x20long\x20as\x20this\x20operation\x20is\x20present,\x20the\x20T\ + able\x20will\n\x20not\x20accept\x20any\x20Table\x20Admin\x20or\x20Read/W\ + rite\x20requests.\n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04)\x02$\x12\n\x0c\ + \n\x05\x04\0\x02\x01\x06\x12\x03)\x02\x1e\n\x0c\n\x05\x04\0\x02\x01\x01\ + \x12\x03)\x1f0\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03)34\nY\n\x04\x04\0\ + \x02\x02\x12\x03,\x020\x1aL\x20The\x20column\x20families\x20configured\ + \x20for\x20this\x20table,\x20mapped\x20by\x20column\x20family\x20id.\n\n\ + \r\n\x05\x04\0\x02\x02\x04\x12\x04,\x02)5\n\x0c\n\x05\x04\0\x02\x02\x06\ + \x12\x03,\x02\x1b\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03,\x1c+\n\x0c\n\ + \x05\x04\0\x02\x02\x03\x12\x03,./\n\xcc\x01\n\x04\x04\0\x02\x03\x12\x031\ + \x02'\x1a\xbe\x01\x20The\x20granularity\x20(e.g.\x20MILLIS,\x20MICROS)\ + \x20at\x20which\x20timestamps\x20are\x20stored\x20in\n\x20this\x20table.\ + \x20Timestamps\x20not\x20matching\x20the\x20granularity\x20will\x20be\ + \x20rejected.\n\x20Cannot\x20be\x20changed\x20once\x20the\x20table\x20is\ + \x20created.\n\n\r\n\x05\x04\0\x02\x03\x04\x12\x041\x02,0\n\x0c\n\x05\ + \x04\0\x02\x03\x06\x12\x031\x02\x16\n\x0c\n\x05\x04\0\x02\x03\x01\x12\ + \x031\x17\"\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x031%&\nQ\n\x02\x04\x01\ + \x12\x045\0^\x01\x1aE\x20A\x20set\x20of\x20columns\x20within\x20a\x20tab\ + le\x20which\x20share\x20a\x20common\x20configuration.\n\n\n\n\x03\x04\ + \x01\x01\x12\x035\x08\x14\n\xac\x01\n\x04\x04\x01\x02\0\x12\x039\x02\x12\ + \x1a\x9e\x01\x20A\x20unique\x20identifier\x20of\x20the\x20form\x20/columnFamilies/[-_.a-zA-Z0-9]+\n\x20The\x20last\x20segment\x20is\ + \x20the\x20same\x20as\x20the\x20\"name\"\x20field\x20in\n\x20google.bigt\ + able.v1.Family.\n\n\r\n\x05\x04\x01\x02\0\x04\x12\x049\x025\x16\n\x0c\n\ + \x05\x04\x01\x02\0\x05\x12\x039\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\ + \x12\x039\t\r\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x039\x10\x11\n\x97\t\n\ + \x04\x04\x01\x02\x01\x12\x03T\x02\x1b\x1a\x89\t\x20Garbage\x20collection\ + \x20expression\x20specified\x20by\x20the\x20following\x20grammar:\n\x20\ + \x20\x20GC\x20=\x20EXPR\n\x20\x20\x20\x20\x20\x20|\x20\"\"\x20;\n\x20\ + \x20\x20EXPR\x20=\x20EXPR,\x20\"||\",\x20EXPR\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20(*\x20lowest\x20precedence\x20*)\n\x20\ + \x20\x20\x20\x20\x20\x20\x20|\x20EXPR,\x20\"&&\",\x20EXPR\n\x20\x20\x20\ + \x20\x20\x20\x20\x20|\x20\"(\",\x20EXPR,\x20\")\"\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20(*\x20highest\x20precedence\ + \x20*)\n\x20\x20\x20\x20\x20\x20\x20\x20|\x20PROP\x20;\n\x20\x20\x20PROP\ + \x20=\x20\"version()\x20>\",\x20NUM32\n\x20\x20\x20\x20\x20\x20\x20\x20|\ + \x20\"age()\x20>\",\x20NUM64,\x20[\x20UNIT\x20]\x20;\n\x20\x20\x20NUM32\ + \x20=\x20non-zero-digit\x20{\x20digit\x20}\x20;\x20\x20\x20\x20(*\x20#\ + \x20NUM32\x20<=\x202^32\x20-\x201\x20*)\n\x20\x20\x20NUM64\x20=\x20non-z\ + ero-digit\x20{\x20digit\x20}\x20;\x20\x20\x20\x20(*\x20#\x20NUM64\x20<=\ + \x202^63\x20-\x201\x20*)\n\x20\x20\x20UNIT\x20=\x20\x20\"d\"\x20|\x20\"h\ + \"\x20|\x20\"m\"\x20\x20(*\x20d=days,\x20h=hours,\x20m=minutes,\x20else\ + \x20micros\x20*)\n\x20GC\x20expressions\x20can\x20be\x20up\x20to\x20500\ + \x20characters\x20in\x20length\n\n\x20The\x20different\x20types\x20of\ + \x20PROP\x20are\x20defined\x20as\x20follows:\n\x20\x20\x20version()\x20-\ + \x20cell\x20index,\x20counting\x20from\x20most\x20recent\x20and\x20start\ + ing\x20at\x201\n\x20\x20\x20age()\x20-\x20age\x20of\x20the\x20cell\x20(c\ + urrent\x20time\x20minus\x20cell\x20timestamp)\n\n\x20Example:\x20\"versi\ + on()\x20>\x203\x20||\x20(age()\x20>\x203d\x20&&\x20version()\x20>\x201)\ + \"\n\x20\x20\x20drop\x20cells\x20beyond\x20the\x20most\x20recent\x20thre\ + e,\x20and\x20drop\x20cells\x20older\x20than\x20three\n\x20\x20\x20days\ + \x20unless\x20they're\x20the\x20most\x20recent\x20cell\x20in\x20the\x20r\ + ow/column\n\n\x20Garbage\x20collection\x20executes\x20opportunistically\ + \x20in\x20the\x20background,\x20and\x20so\n\x20it's\x20possible\x20for\ + \x20reads\x20to\x20return\x20a\x20cell\x20even\x20if\x20it\x20matches\ + \x20the\x20active\x20GC\n\x20expression\x20for\x20its\x20family.\n\n\r\n\ + \x05\x04\x01\x02\x01\x04\x12\x04T\x029\x12\n\x0c\n\x05\x04\x01\x02\x01\ + \x05\x12\x03T\x02\x08\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03T\t\x16\n\ + \x0c\n\x05\x04\x01\x02\x01\x03\x12\x03T\x19\x1a\n\xba\x02\n\x04\x04\x01\ + \x02\x02\x12\x03]\x02\x15\x1a\xac\x02\x20Garbage\x20collection\x20rule\ + \x20specified\x20as\x20a\x20protobuf.\n\x20Supersedes\x20`gc_expression`\ + .\n\x20Must\x20serialize\x20to\x20at\x20most\x20500\x20bytes.\n\n\x20NOT\ + E:\x20Garbage\x20collection\x20executes\x20opportunistically\x20in\x20th\ + e\x20background,\x20and\n\x20so\x20it's\x20possible\x20for\x20reads\x20t\ + o\x20return\x20a\x20cell\x20even\x20if\x20it\x20matches\x20the\x20active\ + \n\x20GC\x20expression\x20for\x20its\x20family.\n\n\r\n\x05\x04\x01\x02\ + \x02\x04\x12\x04]\x02T\x1b\n\x0c\n\x05\x04\x01\x02\x02\x06\x12\x03]\x02\ + \x08\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03]\t\x10\n\x0c\n\x05\x04\x01\ + \x02\x02\x03\x12\x03]\x13\x14\nS\n\x02\x04\x02\x12\x04a\0}\x01\x1aG\x20R\ + ule\x20for\x20determining\x20which\x20cells\x20to\x20delete\x20during\ + \x20garbage\x20collection.\n\n\n\n\x03\x04\x02\x01\x12\x03a\x08\x0e\nM\n\ + \x04\x04\x02\x03\0\x12\x04c\x02f\x03\x1a?\x20A\x20GcRule\x20which\x20del\ + etes\x20cells\x20matching\x20all\x20of\x20the\x20given\x20rules.\n\n\x0c\ + \n\x05\x04\x02\x03\0\x01\x12\x03c\n\x16\nV\n\x06\x04\x02\x03\0\x02\0\x12\ + \x03e\x04\x1e\x1aG\x20Only\x20delete\x20cells\x20which\x20would\x20be\ + \x20deleted\x20by\x20every\x20element\x20of\x20`rules`.\n\n\x0e\n\x07\ + \x04\x02\x03\0\x02\0\x04\x12\x03e\x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\ + \0\x06\x12\x03e\r\x13\n\x0e\n\x07\x04\x02\x03\0\x02\0\x01\x12\x03e\x14\ + \x19\n\x0e\n\x07\x04\x02\x03\0\x02\0\x03\x12\x03e\x1c\x1d\nM\n\x04\x04\ + \x02\x03\x01\x12\x04i\x02l\x03\x1a?\x20A\x20GcRule\x20which\x20deletes\ + \x20cells\x20matching\x20any\x20of\x20the\x20given\x20rules.\n\n\x0c\n\ + \x05\x04\x02\x03\x01\x01\x12\x03i\n\x0f\nO\n\x06\x04\x02\x03\x01\x02\0\ + \x12\x03k\x04\x1e\x1a@\x20Delete\x20cells\x20which\x20would\x20be\x20del\ + eted\x20by\x20any\x20element\x20of\x20`rules`.\n\n\x0e\n\x07\x04\x02\x03\ + \x01\x02\0\x04\x12\x03k\x04\x0c\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x06\ + \x12\x03k\r\x13\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x01\x12\x03k\x14\x19\n\ + \x0e\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x03k\x1c\x1d\n\x0c\n\x04\x04\ + \x02\x08\0\x12\x04n\x02|\x03\n\x0c\n\x05\x04\x02\x08\0\x01\x12\x03n\x08\ + \x0c\nE\n\x04\x04\x02\x02\0\x12\x03p\x04\x1f\x1a8\x20Delete\x20all\x20ce\ + lls\x20in\x20a\x20column\x20except\x20the\x20most\x20recent\x20N.\n\n\ + \x0c\n\x05\x04\x02\x02\0\x05\x12\x03p\x04\t\n\x0c\n\x05\x04\x02\x02\0\ + \x01\x12\x03p\n\x1a\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03p\x1d\x1e\n\x9f\ + \x01\n\x04\x04\x02\x02\x01\x12\x03u\x04)\x1a\x91\x01\x20Delete\x20cells\ + \x20in\x20a\x20column\x20older\x20than\x20the\x20given\x20age.\n\x20Valu\ + es\x20must\x20be\x20at\x20least\x20one\x20millisecond,\x20and\x20will\ + \x20be\x20truncated\x20to\n\x20microsecond\x20granularity.\n\n\x0c\n\x05\ + \x04\x02\x02\x01\x06\x12\x03u\x04\x1c\n\x0c\n\x05\x04\x02\x02\x01\x01\ + \x12\x03u\x1d$\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03u'(\nG\n\x04\x04\ + \x02\x02\x02\x12\x03x\x04\"\x1a:\x20Delete\x20cells\x20that\x20would\x20\ + be\x20deleted\x20by\x20every\x20nested\x20rule.\n\n\x0c\n\x05\x04\x02\ + \x02\x02\x06\x12\x03x\x04\x10\n\x0c\n\x05\x04\x02\x02\x02\x01\x12\x03x\ + \x11\x1d\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03x\x20!\nE\n\x04\x04\x02\ + \x02\x03\x12\x03{\x04\x14\x1a8\x20Delete\x20cells\x20that\x20would\x20be\ + \x20deleted\x20by\x20any\x20nested\x20rule.\n\n\x0c\n\x05\x04\x02\x02\ + \x03\x06\x12\x03{\x04\t\n\x0c\n\x05\x04\x02\x02\x03\x01\x12\x03{\n\x0f\n\ + \x0c\n\x05\x04\x02\x02\x03\x03\x12\x03{\x12\x13b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service.rs new file mode 100644 index 00000000..2e3e0816 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service.rs @@ -0,0 +1,155 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/table/v1/bigtable_table_service.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n;google/bigtable/admin/table/v1/bigtable_table_service.proto\x12\x1ego\ + ogle.bigtable.admin.table.v1\x1a\x1cgoogle/api/annotations.proto\x1a8goo\ + gle/bigtable/admin/table/v1/bigtable_table_data.proto\x1aDgoogle/bigtabl\ + e/admin/table/v1/bigtable_table_service_messages.proto\x1a\x1bgoogle/pro\ + tobuf/empty.proto2\xbe\x0c\n\x14BigtableTableService\x12\xa4\x01\n\x0bCr\ + eateTable\x122.google.bigtable.admin.table.v1.CreateTableRequest\x1a%.go\ + ogle.bigtable.admin.table.v1.Table\":\x82\xd3\xe4\x93\x024\"//v1/{name=p\ + rojects/*/zones/*/clusters/*}/tables:\x01*\x12\xac\x01\n\nListTables\x12\ + 1.google.bigtable.admin.table.v1.ListTablesRequest\x1a2.google.bigtable.\ + admin.table.v1.ListTablesResponse\"7\x82\xd3\xe4\x93\x021\x12//v1/{name=\ + projects/*/zones/*/clusters/*}/tables\x12\x9d\x01\n\x08GetTable\x12/.goo\ + gle.bigtable.admin.table.v1.GetTableRequest\x1a%.google.bigtable.admin.t\ + able.v1.Table\"9\x82\xd3\xe4\x93\x023\x121/v1/{name=projects/*/zones/*/c\ + lusters/*/tables/*}\x12\x94\x01\n\x0bDeleteTable\x122.google.bigtable.ad\ + min.table.v1.DeleteTableRequest\x1a\x16.google.protobuf.Empty\"9\x82\xd3\ + \xe4\x93\x023*1/v1/{name=projects/*/zones/*/clusters/*/tables/*}\x12\x9e\ + \x01\n\x0bRenameTable\x122.google.bigtable.admin.table.v1.RenameTableReq\ + uest\x1a\x16.google.protobuf.Empty\"C\x82\xd3\xe4\x93\x02=\"8/v1/{name=p\ + rojects/*/zones/*/clusters/*/tables/*}:rename:\x01*\x12\xca\x01\n\x12Cre\ + ateColumnFamily\x129.google.bigtable.admin.table.v1.CreateColumnFamilyRe\ + quest\x1a,.google.bigtable.admin.table.v1.ColumnFamily\"K\x82\xd3\xe4\ + \x93\x02E\"@/v1/{name=projects/*/zones/*/clusters/*/tables/*}/columnFami\ + lies:\x01*\x12\xbf\x01\n\x12UpdateColumnFamily\x12,.google.bigtable.admi\ + n.table.v1.ColumnFamily\x1a,.google.bigtable.admin.table.v1.ColumnFamily\ + \"M\x82\xd3\xe4\x93\x02G\x1aB/v1/{name=projects/*/zones/*/clusters/*/tab\ + les/*/columnFamilies/*}:\x01*\x12\xb3\x01\n\x12DeleteColumnFamily\x129.g\ + oogle.bigtable.admin.table.v1.DeleteColumnFamilyRequest\x1a\x16.google.p\ + rotobuf.Empty\"J\x82\xd3\xe4\x93\x02D*B/v1/{name=projects/*/zones/*/clus\ + ters/*/tables/*/columnFamilies/*}\x12\xb2\x01\n\x0eBulkDeleteRows\x125.g\ + oogle.bigtable.admin.table.v1.BulkDeleteRowsRequest\x1a\x16.google.proto\ + buf.Empty\"Q\x82\xd3\xe4\x93\x02K\"F/v1/{table_name=projects/*/zones/*/c\ + lusters/*/tables/*}:bulkDeleteRows:\x01*B\x87\x01\n\"com.google.bigtable\ + .admin.table.v1B\x1aBigtableTableServicesProtoP\x01ZCgoogle.golang.org/g\ + enproto/googleapis/bigtable/admin/table/v1;tableJ\xf9\x12\n\x06\x12\x04\ + \x0e\0O\x01\n\xbd\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\ + \x202017\x20Google\x20Inc.\n\n\x20Licensed\x20under\x20the\x20Apache\x20\ + License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20n\ + ot\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\ + \x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20Lice\ + nse\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-\ + 2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\ + \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\ + \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\ + \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\ + ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\ + the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\ + tations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0'\n\t\ + \n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0B\n\t\n\x02\ + \x03\x02\x12\x03\x14\0N\n\t\n\x02\x03\x03\x12\x03\x15\0%\n\x08\n\x01\x08\ + \x12\x03\x17\0Z\n\t\n\x02\x08\x0b\x12\x03\x17\0Z\n\x08\n\x01\x08\x12\x03\ + \x18\0\"\n\t\n\x02\x08\n\x12\x03\x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0;\ + \n\t\n\x02\x08\x08\x12\x03\x19\0;\n\x08\n\x01\x08\x12\x03\x1a\0;\n\t\n\ + \x02\x08\x01\x12\x03\x1a\0;\n\xa8\x01\n\x02\x06\0\x12\x04\x1f\0O\x01\x1a\ + \x9b\x01\x20Service\x20for\x20creating,\x20configuring,\x20and\x20deleti\ + ng\x20Cloud\x20Bigtable\x20tables.\n\x20Provides\x20access\x20to\x20the\ + \x20table\x20schemas\x20only,\x20not\x20the\x20data\x20stored\x20within\ + \x20the\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03\x1f\x08\x1c\n\xad\x01\n\ + \x04\x06\0\x02\0\x12\x04#\x02%\x03\x1a\x9e\x01\x20Creates\x20a\x20new\ + \x20table,\x20to\x20be\x20served\x20from\x20a\x20specified\x20cluster.\n\ + \x20The\x20table\x20can\x20be\x20created\x20with\x20a\x20full\x20set\x20\ + of\x20initial\x20column\x20families,\n\x20specified\x20in\x20the\x20requ\ + est.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03#\x06\x11\n\x0c\n\x05\x06\0\ + \x02\0\x02\x12\x03#\x12$\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03#/4\n\x0c\n\ + \x05\x06\0\x02\0\x04\x12\x03$\x04e\n\x10\n\t\x06\0\x02\0\x04\xb0\xca\xbc\ + \"\x12\x03$\x04e\nN\n\x04\x06\0\x02\x01\x12\x04(\x02*\x03\x1a@\x20Lists\ + \x20the\x20names\x20of\x20all\x20tables\x20served\x20from\x20a\x20specif\ + ied\x20cluster.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03(\x06\x10\n\x0c\n\ + \x05\x06\0\x02\x01\x02\x12\x03(\x11\"\n\x0c\n\x05\x06\0\x02\x01\x03\x12\ + \x03(-?\n\x0c\n\x05\x06\0\x02\x01\x04\x12\x03)\x04Z\n\x10\n\t\x06\0\x02\ + \x01\x04\xb0\xca\xbc\"\x12\x03)\x04Z\nV\n\x04\x06\0\x02\x02\x12\x04-\x02\ + /\x03\x1aH\x20Gets\x20the\x20schema\x20of\x20the\x20specified\x20table,\ + \x20including\x20its\x20column\x20families.\n\n\x0c\n\x05\x06\0\x02\x02\ + \x01\x12\x03-\x06\x0e\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03-\x0f\x1e\n\ + \x0c\n\x05\x06\0\x02\x02\x03\x12\x03-).\n\x0c\n\x05\x06\0\x02\x02\x04\ + \x12\x03.\x04\\\n\x10\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x03.\x04\\\ + \nJ\n\x04\x06\0\x02\x03\x12\x042\x024\x03\x1a<\x20Permanently\x20deletes\ + \x20a\x20specified\x20table\x20and\x20all\x20of\x20its\x20data.\n\n\x0c\ + \n\x05\x06\0\x02\x03\x01\x12\x032\x06\x11\n\x0c\n\x05\x06\0\x02\x03\x02\ + \x12\x032\x12$\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x032/D\n\x0c\n\x05\x06\ + \0\x02\x03\x04\x12\x033\x04_\n\x10\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\ + \x12\x033\x04_\n{\n\x04\x06\0\x02\x04\x12\x048\x02:\x03\x1am\x20Changes\ + \x20the\x20name\x20of\x20a\x20specified\x20table.\n\x20Cannot\x20be\x20u\ + sed\x20to\x20move\x20tables\x20between\x20clusters,\x20zones,\x20or\x20p\ + rojects.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x038\x06\x11\n\x0c\n\x05\ + \x06\0\x02\x04\x02\x12\x038\x12$\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x038/\ + D\n\x0c\n\x05\x06\0\x02\x04\x04\x12\x039\x04n\n\x10\n\t\x06\0\x02\x04\ + \x04\xb0\xca\xbc\"\x12\x039\x04n\nE\n\x04\x06\0\x02\x05\x12\x04=\x02?\ + \x03\x1a7\x20Creates\x20a\x20new\x20column\x20family\x20within\x20a\x20s\ + pecified\x20table.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03=\x06\x18\n\ + \x0c\n\x05\x06\0\x02\x05\x02\x12\x03=\x192\n\x0c\n\x05\x06\0\x02\x05\x03\ + \x12\x03==I\n\x0c\n\x05\x06\0\x02\x05\x04\x12\x03>\x04v\n\x10\n\t\x06\0\ + \x02\x05\x04\xb0\xca\xbc\"\x12\x03>\x04v\nG\n\x04\x06\0\x02\x06\x12\x04B\ + \x02D\x03\x1a9\x20Changes\x20the\x20configuration\x20of\x20a\x20specifie\ + d\x20column\x20family.\n\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03B\x06\x18\ + \n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03B\x19%\n\x0c\n\x05\x06\0\x02\x06\ + \x03\x12\x03B0<\n\x0c\n\x05\x06\0\x02\x06\x04\x12\x03C\x04w\n\x10\n\t\ + \x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x03C\x04w\nR\n\x04\x06\0\x02\x07\ + \x12\x04G\x02I\x03\x1aD\x20Permanently\x20deletes\x20a\x20specified\x20c\ + olumn\x20family\x20and\x20all\x20of\x20its\x20data.\n\n\x0c\n\x05\x06\0\ + \x02\x07\x01\x12\x03G\x06\x18\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03G\x19\ + 2\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03G=R\n\x0c\n\x05\x06\0\x02\x07\x04\ + \x12\x03H\x04p\n\x10\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x03H\x04p\n\ + O\n\x04\x06\0\x02\x08\x12\x04L\x02N\x03\x1aA\x20Delete\x20all\x20rows\ + \x20in\x20a\x20table\x20corresponding\x20to\x20a\x20particular\x20prefix\ + \n\n\x0c\n\x05\x06\0\x02\x08\x01\x12\x03L\x06\x14\n\x0c\n\x05\x06\0\x02\ + \x08\x02\x12\x03L\x15*\n\x0c\n\x05\x06\0\x02\x08\x03\x12\x03L5J\n\x0c\n\ + \x05\x06\0\x02\x08\x04\x12\x03M\x04|\n\x10\n\t\x06\0\x02\x08\x04\xb0\xca\ + \xbc\"\x12\x03M\x04|b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_grpc.rs new file mode 100644 index 00000000..fdd6807b --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_grpc.rs @@ -0,0 +1,295 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_TABLE_SERVICE_CREATE_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/CreateTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_LIST_TABLES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/ListTables", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_GET_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/GetTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_DELETE_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/DeleteTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_RENAME_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/RenameTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_CREATE_COLUMN_FAMILY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/CreateColumnFamily", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_UPDATE_COLUMN_FAMILY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/UpdateColumnFamily", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_DELETE_COLUMN_FAMILY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/DeleteColumnFamily", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_SERVICE_BULK_DELETE_ROWS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.table.v1.BigtableTableService/BulkDeleteRows", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableTableServiceClient { + client: ::grpcio::Client, +} + +impl BigtableTableServiceClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableTableServiceClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_table_opt(&self, req: &super::bigtable_table_service_messages::CreateTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_TABLE, req, opt) + } + + pub fn create_table(&self, req: &super::bigtable_table_service_messages::CreateTableRequest) -> ::grpcio::Result { + self.create_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_table_async_opt(&self, req: &super::bigtable_table_service_messages::CreateTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_TABLE, req, opt) + } + + pub fn create_table_async(&self, req: &super::bigtable_table_service_messages::CreateTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_tables_opt(&self, req: &super::bigtable_table_service_messages::ListTablesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_LIST_TABLES, req, opt) + } + + pub fn list_tables(&self, req: &super::bigtable_table_service_messages::ListTablesRequest) -> ::grpcio::Result { + self.list_tables_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_tables_async_opt(&self, req: &super::bigtable_table_service_messages::ListTablesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_LIST_TABLES, req, opt) + } + + pub fn list_tables_async(&self, req: &super::bigtable_table_service_messages::ListTablesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_tables_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_table_opt(&self, req: &super::bigtable_table_service_messages::GetTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_GET_TABLE, req, opt) + } + + pub fn get_table(&self, req: &super::bigtable_table_service_messages::GetTableRequest) -> ::grpcio::Result { + self.get_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_table_async_opt(&self, req: &super::bigtable_table_service_messages::GetTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_GET_TABLE, req, opt) + } + + pub fn get_table_async(&self, req: &super::bigtable_table_service_messages::GetTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_table_opt(&self, req: &super::bigtable_table_service_messages::DeleteTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_TABLE, req, opt) + } + + pub fn delete_table(&self, req: &super::bigtable_table_service_messages::DeleteTableRequest) -> ::grpcio::Result { + self.delete_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_table_async_opt(&self, req: &super::bigtable_table_service_messages::DeleteTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_TABLE, req, opt) + } + + pub fn delete_table_async(&self, req: &super::bigtable_table_service_messages::DeleteTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn rename_table_opt(&self, req: &super::bigtable_table_service_messages::RenameTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_RENAME_TABLE, req, opt) + } + + pub fn rename_table(&self, req: &super::bigtable_table_service_messages::RenameTableRequest) -> ::grpcio::Result { + self.rename_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn rename_table_async_opt(&self, req: &super::bigtable_table_service_messages::RenameTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_RENAME_TABLE, req, opt) + } + + pub fn rename_table_async(&self, req: &super::bigtable_table_service_messages::RenameTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.rename_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_column_family_opt(&self, req: &super::bigtable_table_service_messages::CreateColumnFamilyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_COLUMN_FAMILY, req, opt) + } + + pub fn create_column_family(&self, req: &super::bigtable_table_service_messages::CreateColumnFamilyRequest) -> ::grpcio::Result { + self.create_column_family_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_column_family_async_opt(&self, req: &super::bigtable_table_service_messages::CreateColumnFamilyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_COLUMN_FAMILY, req, opt) + } + + pub fn create_column_family_async(&self, req: &super::bigtable_table_service_messages::CreateColumnFamilyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_column_family_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_column_family_opt(&self, req: &super::bigtable_table_data::ColumnFamily, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_UPDATE_COLUMN_FAMILY, req, opt) + } + + pub fn update_column_family(&self, req: &super::bigtable_table_data::ColumnFamily) -> ::grpcio::Result { + self.update_column_family_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_column_family_async_opt(&self, req: &super::bigtable_table_data::ColumnFamily, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_UPDATE_COLUMN_FAMILY, req, opt) + } + + pub fn update_column_family_async(&self, req: &super::bigtable_table_data::ColumnFamily) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_column_family_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_column_family_opt(&self, req: &super::bigtable_table_service_messages::DeleteColumnFamilyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_COLUMN_FAMILY, req, opt) + } + + pub fn delete_column_family(&self, req: &super::bigtable_table_service_messages::DeleteColumnFamilyRequest) -> ::grpcio::Result { + self.delete_column_family_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_column_family_async_opt(&self, req: &super::bigtable_table_service_messages::DeleteColumnFamilyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_COLUMN_FAMILY, req, opt) + } + + pub fn delete_column_family_async(&self, req: &super::bigtable_table_service_messages::DeleteColumnFamilyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_column_family_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn bulk_delete_rows_opt(&self, req: &super::bigtable_table_service_messages::BulkDeleteRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_SERVICE_BULK_DELETE_ROWS, req, opt) + } + + pub fn bulk_delete_rows(&self, req: &super::bigtable_table_service_messages::BulkDeleteRowsRequest) -> ::grpcio::Result { + self.bulk_delete_rows_opt(req, ::grpcio::CallOption::default()) + } + + pub fn bulk_delete_rows_async_opt(&self, req: &super::bigtable_table_service_messages::BulkDeleteRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_SERVICE_BULK_DELETE_ROWS, req, opt) + } + + pub fn bulk_delete_rows_async(&self, req: &super::bigtable_table_service_messages::BulkDeleteRowsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.bulk_delete_rows_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait BigtableTableService { + fn create_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::CreateTableRequest, sink: ::grpcio::UnarySink); + fn list_tables(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::ListTablesRequest, sink: ::grpcio::UnarySink); + fn get_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::GetTableRequest, sink: ::grpcio::UnarySink); + fn delete_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::DeleteTableRequest, sink: ::grpcio::UnarySink); + fn rename_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::RenameTableRequest, sink: ::grpcio::UnarySink); + fn create_column_family(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::CreateColumnFamilyRequest, sink: ::grpcio::UnarySink); + fn update_column_family(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_data::ColumnFamily, sink: ::grpcio::UnarySink); + fn delete_column_family(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::DeleteColumnFamilyRequest, sink: ::grpcio::UnarySink); + fn bulk_delete_rows(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_service_messages::BulkDeleteRowsRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable_table_service(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_TABLE, move |ctx, req, resp| { + instance.create_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_LIST_TABLES, move |ctx, req, resp| { + instance.list_tables(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_GET_TABLE, move |ctx, req, resp| { + instance.get_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_TABLE, move |ctx, req, resp| { + instance.delete_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_RENAME_TABLE, move |ctx, req, resp| { + instance.rename_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_CREATE_COLUMN_FAMILY, move |ctx, req, resp| { + instance.create_column_family(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_UPDATE_COLUMN_FAMILY, move |ctx, req, resp| { + instance.update_column_family(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_DELETE_COLUMN_FAMILY, move |ctx, req, resp| { + instance.delete_column_family(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_SERVICE_BULK_DELETE_ROWS, move |ctx, req, resp| { + instance.bulk_delete_rows(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_messages.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_messages.rs new file mode 100644 index 00000000..fd59a98d --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/bigtable_table_service_messages.rs @@ -0,0 +1,2137 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/table/v1/bigtable_table_service_messages.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct CreateTableRequest { + // message fields + pub name: ::std::string::String, + pub table_id: ::std::string::String, + pub table: ::protobuf::SingularPtrField, + pub initial_split_keys: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateTableRequest { + fn default() -> &'a CreateTableRequest { + ::default_instance() + } +} + +impl CreateTableRequest { + pub fn new() -> CreateTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string table_id = 2; + + + pub fn get_table_id(&self) -> &str { + &self.table_id + } + pub fn clear_table_id(&mut self) { + self.table_id.clear(); + } + + // Param is passed by value, moved + pub fn set_table_id(&mut self, v: ::std::string::String) { + self.table_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_id(&mut self) -> &mut ::std::string::String { + &mut self.table_id + } + + // Take field + pub fn take_table_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.table.v1.Table table = 3; + + + pub fn get_table(&self) -> &super::bigtable_table_data::Table { + self.table.as_ref().unwrap_or_else(|| super::bigtable_table_data::Table::default_instance()) + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + pub fn has_table(&self) -> bool { + self.table.is_some() + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: super::bigtable_table_data::Table) { + self.table = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut super::bigtable_table_data::Table { + if self.table.is_none() { + self.table.set_default(); + } + self.table.as_mut().unwrap() + } + + // Take field + pub fn take_table(&mut self) -> super::bigtable_table_data::Table { + self.table.take().unwrap_or_else(|| super::bigtable_table_data::Table::new()) + } + + // repeated string initial_split_keys = 4; + + + pub fn get_initial_split_keys(&self) -> &[::std::string::String] { + &self.initial_split_keys + } + pub fn clear_initial_split_keys(&mut self) { + self.initial_split_keys.clear(); + } + + // Param is passed by value, moved + pub fn set_initial_split_keys(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.initial_split_keys = v; + } + + // Mutable pointer to the field. + pub fn mut_initial_split_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.initial_split_keys + } + + // Take field + pub fn take_initial_split_keys(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.initial_split_keys, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CreateTableRequest { + fn is_initialized(&self) -> bool { + for v in &self.table { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.table)?; + }, + 4 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.initial_split_keys)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.table_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.table_id); + } + if let Some(ref v) = self.table.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.initial_split_keys { + my_size += ::protobuf::rt::string_size(4, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.table_id.is_empty() { + os.write_string(2, &self.table_id)?; + } + if let Some(ref v) = self.table.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.initial_split_keys { + os.write_string(4, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateTableRequest { + CreateTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CreateTableRequest| { &m.name }, + |m: &mut CreateTableRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_id", + |m: &CreateTableRequest| { &m.table_id }, + |m: &mut CreateTableRequest| { &mut m.table_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "table", + |m: &CreateTableRequest| { &m.table }, + |m: &mut CreateTableRequest| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "initial_split_keys", + |m: &CreateTableRequest| { &m.initial_split_keys }, + |m: &mut CreateTableRequest| { &mut m.initial_split_keys }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateTableRequest, + }; + unsafe { + instance.get(CreateTableRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.table_id.clear(); + self.table.clear(); + self.initial_split_keys.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTablesRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTablesRequest { + fn default() -> &'a ListTablesRequest { + ::default_instance() + } +} + +impl ListTablesRequest { + pub fn new() -> ListTablesRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTablesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTablesRequest { + ListTablesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ListTablesRequest| { &m.name }, + |m: &mut ListTablesRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTablesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTablesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTablesRequest, + }; + unsafe { + instance.get(ListTablesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTablesRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTablesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTablesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTablesResponse { + // message fields + pub tables: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTablesResponse { + fn default() -> &'a ListTablesResponse { + ::default_instance() + } +} + +impl ListTablesResponse { + pub fn new() -> ListTablesResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.table.v1.Table tables = 1; + + + pub fn get_tables(&self) -> &[super::bigtable_table_data::Table] { + &self.tables + } + pub fn clear_tables(&mut self) { + self.tables.clear(); + } + + // Param is passed by value, moved + pub fn set_tables(&mut self, v: ::protobuf::RepeatedField) { + self.tables = v; + } + + // Mutable pointer to the field. + pub fn mut_tables(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.tables + } + + // Take field + pub fn take_tables(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.tables, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ListTablesResponse { + fn is_initialized(&self) -> bool { + for v in &self.tables { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tables)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.tables { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.tables { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTablesResponse { + ListTablesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "tables", + |m: &ListTablesResponse| { &m.tables }, + |m: &mut ListTablesResponse| { &mut m.tables }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTablesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTablesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTablesResponse, + }; + unsafe { + instance.get(ListTablesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTablesResponse { + fn clear(&mut self) { + self.tables.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTablesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTablesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetTableRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetTableRequest { + fn default() -> &'a GetTableRequest { + ::default_instance() + } +} + +impl GetTableRequest { + pub fn new() -> GetTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetTableRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetTableRequest { + GetTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetTableRequest| { &m.name }, + |m: &mut GetTableRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetTableRequest, + }; + unsafe { + instance.get(GetTableRequest::new) + } + } +} + +impl ::protobuf::Clear for GetTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteTableRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteTableRequest { + fn default() -> &'a DeleteTableRequest { + ::default_instance() + } +} + +impl DeleteTableRequest { + pub fn new() -> DeleteTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteTableRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteTableRequest { + DeleteTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteTableRequest| { &m.name }, + |m: &mut DeleteTableRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteTableRequest, + }; + unsafe { + instance.get(DeleteTableRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RenameTableRequest { + // message fields + pub name: ::std::string::String, + pub new_id: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RenameTableRequest { + fn default() -> &'a RenameTableRequest { + ::default_instance() + } +} + +impl RenameTableRequest { + pub fn new() -> RenameTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string new_id = 2; + + + pub fn get_new_id(&self) -> &str { + &self.new_id + } + pub fn clear_new_id(&mut self) { + self.new_id.clear(); + } + + // Param is passed by value, moved + pub fn set_new_id(&mut self, v: ::std::string::String) { + self.new_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_new_id(&mut self) -> &mut ::std::string::String { + &mut self.new_id + } + + // Take field + pub fn take_new_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.new_id, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for RenameTableRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.new_id)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.new_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.new_id); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.new_id.is_empty() { + os.write_string(2, &self.new_id)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RenameTableRequest { + RenameTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &RenameTableRequest| { &m.name }, + |m: &mut RenameTableRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "new_id", + |m: &RenameTableRequest| { &m.new_id }, + |m: &mut RenameTableRequest| { &mut m.new_id }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RenameTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RenameTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RenameTableRequest, + }; + unsafe { + instance.get(RenameTableRequest::new) + } + } +} + +impl ::protobuf::Clear for RenameTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.new_id.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RenameTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RenameTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateColumnFamilyRequest { + // message fields + pub name: ::std::string::String, + pub column_family_id: ::std::string::String, + pub column_family: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateColumnFamilyRequest { + fn default() -> &'a CreateColumnFamilyRequest { + ::default_instance() + } +} + +impl CreateColumnFamilyRequest { + pub fn new() -> CreateColumnFamilyRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string column_family_id = 2; + + + pub fn get_column_family_id(&self) -> &str { + &self.column_family_id + } + pub fn clear_column_family_id(&mut self) { + self.column_family_id.clear(); + } + + // Param is passed by value, moved + pub fn set_column_family_id(&mut self, v: ::std::string::String) { + self.column_family_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_family_id(&mut self) -> &mut ::std::string::String { + &mut self.column_family_id + } + + // Take field + pub fn take_column_family_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.column_family_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.table.v1.ColumnFamily column_family = 3; + + + pub fn get_column_family(&self) -> &super::bigtable_table_data::ColumnFamily { + self.column_family.as_ref().unwrap_or_else(|| super::bigtable_table_data::ColumnFamily::default_instance()) + } + pub fn clear_column_family(&mut self) { + self.column_family.clear(); + } + + pub fn has_column_family(&self) -> bool { + self.column_family.is_some() + } + + // Param is passed by value, moved + pub fn set_column_family(&mut self, v: super::bigtable_table_data::ColumnFamily) { + self.column_family = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_family(&mut self) -> &mut super::bigtable_table_data::ColumnFamily { + if self.column_family.is_none() { + self.column_family.set_default(); + } + self.column_family.as_mut().unwrap() + } + + // Take field + pub fn take_column_family(&mut self) -> super::bigtable_table_data::ColumnFamily { + self.column_family.take().unwrap_or_else(|| super::bigtable_table_data::ColumnFamily::new()) + } +} + +impl ::protobuf::Message for CreateColumnFamilyRequest { + fn is_initialized(&self) -> bool { + for v in &self.column_family { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.column_family_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.column_family)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.column_family_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.column_family_id); + } + if let Some(ref v) = self.column_family.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.column_family_id.is_empty() { + os.write_string(2, &self.column_family_id)?; + } + if let Some(ref v) = self.column_family.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateColumnFamilyRequest { + CreateColumnFamilyRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CreateColumnFamilyRequest| { &m.name }, + |m: &mut CreateColumnFamilyRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "column_family_id", + |m: &CreateColumnFamilyRequest| { &m.column_family_id }, + |m: &mut CreateColumnFamilyRequest| { &mut m.column_family_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "column_family", + |m: &CreateColumnFamilyRequest| { &m.column_family }, + |m: &mut CreateColumnFamilyRequest| { &mut m.column_family }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateColumnFamilyRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateColumnFamilyRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateColumnFamilyRequest, + }; + unsafe { + instance.get(CreateColumnFamilyRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateColumnFamilyRequest { + fn clear(&mut self) { + self.name.clear(); + self.column_family_id.clear(); + self.column_family.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateColumnFamilyRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateColumnFamilyRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteColumnFamilyRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteColumnFamilyRequest { + fn default() -> &'a DeleteColumnFamilyRequest { + ::default_instance() + } +} + +impl DeleteColumnFamilyRequest { + pub fn new() -> DeleteColumnFamilyRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteColumnFamilyRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteColumnFamilyRequest { + DeleteColumnFamilyRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteColumnFamilyRequest| { &m.name }, + |m: &mut DeleteColumnFamilyRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteColumnFamilyRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteColumnFamilyRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteColumnFamilyRequest, + }; + unsafe { + instance.get(DeleteColumnFamilyRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteColumnFamilyRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteColumnFamilyRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteColumnFamilyRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct BulkDeleteRowsRequest { + // message fields + pub table_name: ::std::string::String, + // message oneof groups + pub target: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BulkDeleteRowsRequest { + fn default() -> &'a BulkDeleteRowsRequest { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum BulkDeleteRowsRequest_oneof_target { + row_key_prefix(::std::vec::Vec), + delete_all_data_from_table(bool), +} + +impl BulkDeleteRowsRequest { + pub fn new() -> BulkDeleteRowsRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // bytes row_key_prefix = 2; + + + pub fn get_row_key_prefix(&self) -> &[u8] { + match self.target { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(ref v)) => v, + _ => &[], + } + } + pub fn clear_row_key_prefix(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_row_key_prefix(&self) -> bool { + match self.target { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_key_prefix(&mut self, v: ::std::vec::Vec) { + self.target = ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_key_prefix(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(::std::vec::Vec::new())); + } + match self.target { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_key_prefix(&mut self) -> ::std::vec::Vec { + if self.has_row_key_prefix() { + match self.target.take() { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bool delete_all_data_from_table = 3; + + + pub fn get_delete_all_data_from_table(&self) -> bool { + match self.target { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(v)) => v, + _ => false, + } + } + pub fn clear_delete_all_data_from_table(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_delete_all_data_from_table(&self) -> bool { + match self.target { + ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_all_data_from_table(&mut self, v: bool) { + self.target = ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(v)) + } +} + +impl ::protobuf::Message for BulkDeleteRowsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::row_key_prefix(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &BulkDeleteRowsRequest_oneof_target::row_key_prefix(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &BulkDeleteRowsRequest_oneof_target::row_key_prefix(ref v) => { + os.write_bytes(2, v)?; + }, + &BulkDeleteRowsRequest_oneof_target::delete_all_data_from_table(v) => { + os.write_bool(3, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BulkDeleteRowsRequest { + BulkDeleteRowsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &BulkDeleteRowsRequest| { &m.table_name }, + |m: &mut BulkDeleteRowsRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "row_key_prefix", + BulkDeleteRowsRequest::has_row_key_prefix, + BulkDeleteRowsRequest::get_row_key_prefix, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "delete_all_data_from_table", + BulkDeleteRowsRequest::has_delete_all_data_from_table, + BulkDeleteRowsRequest::get_delete_all_data_from_table, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BulkDeleteRowsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BulkDeleteRowsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BulkDeleteRowsRequest, + }; + unsafe { + instance.get(BulkDeleteRowsRequest::new) + } + } +} + +impl ::protobuf::Clear for BulkDeleteRowsRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.target = ::std::option::Option::None; + self.target = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BulkDeleteRowsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BulkDeleteRowsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \nDgoogle/bigtable/admin/table/v1/bigtable_table_service_messages.proto\ + \x12\x1egoogle.bigtable.admin.table.v1\x1a8google/bigtable/admin/table/v\ + 1/bigtable_table_data.proto\"\xae\x01\n\x12CreateTableRequest\x12\x12\n\ + \x04name\x18\x01\x20\x01(\tR\x04name\x12\x19\n\x08table_id\x18\x02\x20\ + \x01(\tR\x07tableId\x12;\n\x05table\x18\x03\x20\x01(\x0b2%.google.bigtab\ + le.admin.table.v1.TableR\x05table\x12,\n\x12initial_split_keys\x18\x04\ + \x20\x03(\tR\x10initialSplitKeys\"'\n\x11ListTablesRequest\x12\x12\n\x04\ + name\x18\x01\x20\x01(\tR\x04name\"S\n\x12ListTablesResponse\x12=\n\x06ta\ + bles\x18\x01\x20\x03(\x0b2%.google.bigtable.admin.table.v1.TableR\x06tab\ + les\"%\n\x0fGetTableRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04nam\ + e\"(\n\x12DeleteTableRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04na\ + me\"?\n\x12RenameTableRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\ + ame\x12\x15\n\x06new_id\x18\x02\x20\x01(\tR\x05newId\"\xac\x01\n\x19Crea\ + teColumnFamilyRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12(\ + \n\x10column_family_id\x18\x02\x20\x01(\tR\x0ecolumnFamilyId\x12Q\n\rcol\ + umn_family\x18\x03\x20\x01(\x0b2,.google.bigtable.admin.table.v1.ColumnF\ + amilyR\x0ccolumnFamily\"/\n\x19DeleteColumnFamilyRequest\x12\x12\n\x04na\ + me\x18\x01\x20\x01(\tR\x04name\"\xa6\x01\n\x15BulkDeleteRowsRequest\x12\ + \x1d\n\ntable_name\x18\x01\x20\x01(\tR\ttableName\x12&\n\x0erow_key_pref\ + ix\x18\x02\x20\x01(\x0cH\0R\x0crowKeyPrefix\x12<\n\x1adelete_all_data_fr\ + om_table\x18\x03\x20\x01(\x08H\0R\x16deleteAllDataFromTableB\x08\n\x06ta\ + rgetB\x8e\x01\n\"com.google.bigtable.admin.table.v1B!BigtableTableServic\ + eMessagesProtoP\x01ZCgoogle.golang.org/genproto/googleapis/bigtable/admi\ + n/table/v1;tableJ\x85!\n\x06\x12\x04\x0e\0s\x01\n\xbd\x04\n\x01\x0c\x12\ + \x03\x0e\0\x122\xb2\x04\x20Copyright\x202017\x20Google\x20Inc.\n\n\x20Li\ + censed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\ + \x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20excep\ + t\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obta\ + in\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20htt\ + p://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\ + \x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20softwar\ + e\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\ + \x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CON\ + DITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\ + \x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20gover\ + ning\x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\ + \n\n\x08\n\x01\x02\x12\x03\x10\0'\n\t\n\x02\x03\0\x12\x03\x12\0B\n\x08\n\ + \x01\x08\x12\x03\x14\0Z\n\t\n\x02\x08\x0b\x12\x03\x14\0Z\n\x08\n\x01\x08\ + \x12\x03\x15\0\"\n\t\n\x02\x08\n\x12\x03\x15\0\"\n\x08\n\x01\x08\x12\x03\ + \x16\0B\n\t\n\x02\x08\x08\x12\x03\x16\0B\n\x08\n\x01\x08\x12\x03\x17\0;\ + \n\t\n\x02\x08\x01\x12\x03\x17\0;\n\n\n\x02\x04\0\x12\x04\x1a\06\x01\n\n\ + \n\x03\x04\0\x01\x12\x03\x1a\x08\x1a\nO\n\x04\x04\0\x02\0\x12\x03\x1c\ + \x02\x12\x1aB\x20The\x20unique\x20name\x20of\x20the\x20cluster\x20in\x20\ + which\x20to\x20create\x20the\x20new\x20table.\n\n\r\n\x05\x04\0\x02\0\ + \x04\x12\x04\x1c\x02\x1a\x1c\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x1c\x02\ + \x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x1c\t\r\n\x0c\n\x05\x04\0\x02\0\ + \x03\x12\x03\x1c\x10\x11\n\x94\x01\n\x04\x04\0\x02\x01\x12\x03\x20\x02\ + \x16\x1a\x86\x01\x20The\x20name\x20by\x20which\x20the\x20new\x20table\ + \x20should\x20be\x20referred\x20to\x20within\x20the\x20cluster,\n\x20e.g\ + .\x20\"foobar\"\x20rather\x20than\x20\"/tables/foobar\".\n\ + \n\r\n\x05\x04\0\x02\x01\x04\x12\x04\x20\x02\x1c\x12\n\x0c\n\x05\x04\0\ + \x02\x01\x05\x12\x03\x20\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\ + \x20\t\x11\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x20\x14\x15\n\x9c\x01\n\ + \x04\x04\0\x02\x02\x12\x03$\x02\x12\x1a\x8e\x01\x20The\x20Table\x20to\ + \x20create.\x20The\x20`name`\x20field\x20of\x20the\x20Table\x20and\x20al\ + l\x20of\x20its\n\x20ColumnFamilies\x20must\x20be\x20left\x20blank,\x20an\ + d\x20will\x20be\x20populated\x20in\x20the\x20response.\n\n\r\n\x05\x04\0\ + \x02\x02\x04\x12\x04$\x02\x20\x16\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03$\ + \x02\x07\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03$\x08\r\n\x0c\n\x05\x04\0\ + \x02\x02\x03\x12\x03$\x10\x11\n\x84\x06\n\x04\x04\0\x02\x03\x12\x035\x02\ + )\x1a\xf6\x05\x20The\x20optional\x20list\x20of\x20row\x20keys\x20that\ + \x20will\x20be\x20used\x20to\x20initially\x20split\x20the\n\x20table\x20\ + into\x20several\x20tablets\x20(Tablets\x20are\x20similar\x20to\x20HBase\ + \x20regions).\n\x20Given\x20two\x20split\x20keys,\x20\"s1\"\x20and\x20\"\ + s2\",\x20three\x20tablets\x20will\x20be\x20created,\n\x20spanning\x20the\ + \x20key\x20ranges:\x20[,\x20s1),\x20[s1,\x20s2),\x20[s2,\x20).\n\n\x20Ex\ + ample:\n\x20\x20*\x20Row\x20keys\x20:=\x20[\"a\",\x20\"apple\",\x20\"cus\ + tom\",\x20\"customer_1\",\x20\"customer_2\",\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"other\",\x20\"zz\"]\n\x20\ + \x20*\x20initial_split_keys\x20:=\x20[\"apple\",\x20\"customer_1\",\x20\ + \"customer_2\",\x20\"other\"]\n\x20\x20*\x20Key\x20assignment:\n\x20\x20\ + \x20\x20-\x20Tablet\x201\x20[,\x20apple)\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20=>\x20{\"a\"}.\n\x20\x20\x20\x20-\x20Tab\ + let\x202\x20[apple,\x20customer_1)\x20\x20\x20\x20\x20\x20=>\x20{\"apple\ + \",\x20\"custom\"}.\n\x20\x20\x20\x20-\x20Tablet\x203\x20[customer_1,\ + \x20customer_2)\x20=>\x20{\"customer_1\"}.\n\x20\x20\x20\x20-\x20Tablet\ + \x204\x20[customer_2,\x20other)\x20\x20\x20\x20\x20\x20=>\x20{\"customer\ + _2\"}.\n\x20\x20\x20\x20-\x20Tablet\x205\x20[other,\x20)\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20=>\x20{\"other\",\x20\"z\ + z\"}.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x035\x02\n\n\x0c\n\x05\x04\0\ + \x02\x03\x05\x12\x035\x0b\x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x035\x12\ + $\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x035'(\n\n\n\x02\x04\x01\x12\x048\0;\ + \x01\n\n\n\x03\x04\x01\x01\x12\x038\x08\x19\nP\n\x04\x04\x01\x02\0\x12\ + \x03:\x02\x12\x1aC\x20The\x20unique\x20name\x20of\x20the\x20cluster\x20f\ + or\x20which\x20tables\x20should\x20be\x20listed.\n\n\r\n\x05\x04\x01\x02\ + \0\x04\x12\x04:\x028\x1b\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03:\x02\x08\ + \n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03:\t\r\n\x0c\n\x05\x04\x01\x02\0\ + \x03\x12\x03:\x10\x11\n\n\n\x02\x04\x02\x12\x04=\0A\x01\n\n\n\x03\x04\ + \x02\x01\x12\x03=\x08\x1a\nt\n\x04\x04\x02\x02\0\x12\x03@\x02\x1c\x1ag\ + \x20The\x20tables\x20present\x20in\x20the\x20requested\x20cluster.\n\x20\ + At\x20present,\x20only\x20the\x20names\x20of\x20the\x20tables\x20are\x20\ + populated.\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03@\x02\n\n\x0c\n\x05\ + \x04\x02\x02\0\x06\x12\x03@\x0b\x10\n\x0c\n\x05\x04\x02\x02\0\x01\x12\ + \x03@\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03@\x1a\x1b\n\n\n\x02\ + \x04\x03\x12\x04C\0F\x01\n\n\n\x03\x04\x03\x01\x12\x03C\x08\x17\n6\n\x04\ + \x04\x03\x02\0\x12\x03E\x02\x12\x1a)\x20The\x20unique\x20name\x20of\x20t\ + he\x20requested\x20table.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04E\x02C\ + \x19\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03E\x02\x08\n\x0c\n\x05\x04\x03\ + \x02\0\x01\x12\x03E\t\r\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03E\x10\x11\n\ + \n\n\x02\x04\x04\x12\x04H\0K\x01\n\n\n\x03\x04\x04\x01\x12\x03H\x08\x1a\ + \n:\n\x04\x04\x04\x02\0\x12\x03J\x02\x12\x1a-\x20The\x20unique\x20name\ + \x20of\x20the\x20table\x20to\x20be\x20deleted.\n\n\r\n\x05\x04\x04\x02\0\ + \x04\x12\x04J\x02H\x1c\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03J\x02\x08\n\ + \x0c\n\x05\x04\x04\x02\0\x01\x12\x03J\t\r\n\x0c\n\x05\x04\x04\x02\0\x03\ + \x12\x03J\x10\x11\n\n\n\x02\x04\x05\x12\x04M\0T\x01\n\n\n\x03\x04\x05\ + \x01\x12\x03M\x08\x1a\n4\n\x04\x04\x05\x02\0\x12\x03O\x02\x12\x1a'\x20Th\ + e\x20current\x20unique\x20name\x20of\x20the\x20table.\n\n\r\n\x05\x04\ + \x05\x02\0\x04\x12\x04O\x02M\x1c\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03O\ + \x02\x08\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03O\t\r\n\x0c\n\x05\x04\x05\ + \x02\0\x03\x12\x03O\x10\x11\n\x9f\x01\n\x04\x04\x05\x02\x01\x12\x03S\x02\ + \x14\x1a\x91\x01\x20The\x20new\x20name\x20by\x20which\x20the\x20table\ + \x20should\x20be\x20referred\x20to\x20within\x20its\x20containing\n\x20c\ + luster,\x20e.g.\x20\"foobar\"\x20rather\x20than\x20\"/tabl\ + es/foobar\".\n\n\r\n\x05\x04\x05\x02\x01\x04\x12\x04S\x02O\x12\n\x0c\n\ + \x05\x04\x05\x02\x01\x05\x12\x03S\x02\x08\n\x0c\n\x05\x04\x05\x02\x01\ + \x01\x12\x03S\t\x0f\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03S\x12\x13\n\n\ + \n\x02\x04\x06\x12\x04V\0`\x01\n\n\n\x03\x04\x06\x01\x12\x03V\x08!\nU\n\ + \x04\x04\x06\x02\0\x12\x03X\x02\x12\x1aH\x20The\x20unique\x20name\x20of\ + \x20the\x20table\x20in\x20which\x20to\x20create\x20the\x20new\x20column\ + \x20family.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04X\x02V#\n\x0c\n\x05\x04\ + \x06\x02\0\x05\x12\x03X\x02\x08\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03X\t\ + \r\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03X\x10\x11\n\xa0\x01\n\x04\x04\ + \x06\x02\x01\x12\x03\\\x02\x1e\x1a\x92\x01\x20The\x20name\x20by\x20which\ + \x20the\x20new\x20column\x20family\x20should\x20be\x20referred\x20to\x20\ + within\x20the\n\x20table,\x20e.g.\x20\"foobar\"\x20rather\x20than\x20\"<\ + table_name>/columnFamilies/foobar\".\n\n\r\n\x05\x04\x06\x02\x01\x04\x12\ + \x04\\\x02X\x12\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03\\\x02\x08\n\x0c\ + \n\x05\x04\x06\x02\x01\x01\x12\x03\\\t\x19\n\x0c\n\x05\x04\x06\x02\x01\ + \x03\x12\x03\\\x1c\x1d\nP\n\x04\x04\x06\x02\x02\x12\x03_\x02!\x1aC\x20Th\ + e\x20column\x20family\x20to\x20create.\x20The\x20`name`\x20field\x20must\ + \x20be\x20left\x20blank.\n\n\r\n\x05\x04\x06\x02\x02\x04\x12\x04_\x02\\\ + \x1e\n\x0c\n\x05\x04\x06\x02\x02\x06\x12\x03_\x02\x0e\n\x0c\n\x05\x04\ + \x06\x02\x02\x01\x12\x03_\x0f\x1c\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\ + \x03_\x1f\x20\n\n\n\x02\x04\x07\x12\x04b\0e\x01\n\n\n\x03\x04\x07\x01\ + \x12\x03b\x08!\nB\n\x04\x04\x07\x02\0\x12\x03d\x02\x12\x1a5\x20The\x20un\ + ique\x20name\x20of\x20the\x20column\x20family\x20to\x20be\x20deleted.\n\ + \n\r\n\x05\x04\x07\x02\0\x04\x12\x04d\x02b#\n\x0c\n\x05\x04\x07\x02\0\ + \x05\x12\x03d\x02\x08\n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03d\t\r\n\x0c\n\ + \x05\x04\x07\x02\0\x03\x12\x03d\x10\x11\n\n\n\x02\x04\x08\x12\x04g\0s\ + \x01\n\n\n\x03\x04\x08\x01\x12\x03g\x08\x1d\nO\n\x04\x04\x08\x02\0\x12\ + \x03i\x02\x18\x1aB\x20The\x20unique\x20name\x20of\x20the\x20table\x20on\ + \x20which\x20to\x20perform\x20the\x20bulk\x20delete\n\n\r\n\x05\x04\x08\ + \x02\0\x04\x12\x04i\x02g\x1f\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03i\x02\ + \x08\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03i\t\x13\n\x0c\n\x05\x04\x08\ + \x02\0\x03\x12\x03i\x16\x17\n\x0c\n\x04\x04\x08\x08\0\x12\x04k\x02r\x03\ + \n\x0c\n\x05\x04\x08\x08\0\x01\x12\x03k\x08\x0e\nb\n\x04\x04\x08\x02\x01\ + \x12\x03n\x04\x1d\x1aU\x20Delete\x20all\x20rows\x20that\x20start\x20with\ + \x20this\x20row\x20key\x20prefix.\x20Prefix\x20cannot\x20be\n\x20zero\ + \x20length.\n\n\x0c\n\x05\x04\x08\x02\x01\x05\x12\x03n\x04\t\n\x0c\n\x05\ + \x04\x08\x02\x01\x01\x12\x03n\n\x18\n\x0c\n\x05\x04\x08\x02\x01\x03\x12\ + \x03n\x1b\x1c\nN\n\x04\x04\x08\x02\x02\x12\x03q\x04(\x1aA\x20Delete\x20a\ + ll\x20rows\x20in\x20the\x20table.\x20Setting\x20this\x20to\x20false\x20i\ + s\x20a\x20no-op.\n\n\x0c\n\x05\x04\x08\x02\x02\x05\x12\x03q\x04\x08\n\ + \x0c\n\x05\x04\x08\x02\x02\x01\x12\x03q\t#\n\x0c\n\x05\x04\x08\x02\x02\ + \x03\x12\x03q&'b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/mod.rs new file mode 100644 index 00000000..aff0a6bb --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/table/v1/mod.rs @@ -0,0 +1,7 @@ +pub mod bigtable_table_data; +pub mod bigtable_table_service; +pub mod bigtable_table_service_grpc; +pub mod bigtable_table_service_messages; + +pub(crate) use crate::empty; +pub(crate) use crate::longrunning::operations; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin.rs new file mode 100644 index 00000000..ec9b808d --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin.rs @@ -0,0 +1,5872 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/v2/bigtable_instance_admin.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct CreateInstanceRequest { + // message fields + pub parent: ::std::string::String, + pub instance_id: ::std::string::String, + pub instance: ::protobuf::SingularPtrField, + pub clusters: ::std::collections::HashMap<::std::string::String, super::instance::Cluster>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateInstanceRequest { + fn default() -> &'a CreateInstanceRequest { + ::default_instance() + } +} + +impl CreateInstanceRequest { + pub fn new() -> CreateInstanceRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string instance_id = 2; + + + pub fn get_instance_id(&self) -> &str { + &self.instance_id + } + pub fn clear_instance_id(&mut self) { + self.instance_id.clear(); + } + + // Param is passed by value, moved + pub fn set_instance_id(&mut self, v: ::std::string::String) { + self.instance_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance_id(&mut self) -> &mut ::std::string::String { + &mut self.instance_id + } + + // Take field + pub fn take_instance_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.instance_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Instance instance = 3; + + + pub fn get_instance(&self) -> &super::instance::Instance { + self.instance.as_ref().unwrap_or_else(|| super::instance::Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: super::instance::Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut super::instance::Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> super::instance::Instance { + self.instance.take().unwrap_or_else(|| super::instance::Instance::new()) + } + + // repeated .google.bigtable.admin.v2.CreateInstanceRequest.ClustersEntry clusters = 4; + + + pub fn get_clusters(&self) -> &::std::collections::HashMap<::std::string::String, super::instance::Cluster> { + &self.clusters + } + pub fn clear_clusters(&mut self) { + self.clusters.clear(); + } + + // Param is passed by value, moved + pub fn set_clusters(&mut self, v: ::std::collections::HashMap<::std::string::String, super::instance::Cluster>) { + self.clusters = v; + } + + // Mutable pointer to the field. + pub fn mut_clusters(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::instance::Cluster> { + &mut self.clusters + } + + // Take field + pub fn take_clusters(&mut self) -> ::std::collections::HashMap<::std::string::String, super::instance::Cluster> { + ::std::mem::replace(&mut self.clusters, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for CreateInstanceRequest { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.instance_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + 4 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.clusters)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.instance_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.instance_id); + } + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(4, &self.clusters); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.instance_id.is_empty() { + os.write_string(2, &self.instance_id)?; + } + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(4, &self.clusters, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateInstanceRequest { + CreateInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateInstanceRequest| { &m.parent }, + |m: &mut CreateInstanceRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "instance_id", + |m: &CreateInstanceRequest| { &m.instance_id }, + |m: &mut CreateInstanceRequest| { &mut m.instance_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &CreateInstanceRequest| { &m.instance }, + |m: &mut CreateInstanceRequest| { &mut m.instance }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "clusters", + |m: &CreateInstanceRequest| { &m.clusters }, + |m: &mut CreateInstanceRequest| { &mut m.clusters }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateInstanceRequest, + }; + unsafe { + instance.get(CreateInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateInstanceRequest { + fn clear(&mut self) { + self.parent.clear(); + self.instance_id.clear(); + self.instance.clear(); + self.clusters.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetInstanceRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetInstanceRequest { + fn default() -> &'a GetInstanceRequest { + ::default_instance() + } +} + +impl GetInstanceRequest { + pub fn new() -> GetInstanceRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetInstanceRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetInstanceRequest { + GetInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetInstanceRequest| { &m.name }, + |m: &mut GetInstanceRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetInstanceRequest, + }; + unsafe { + instance.get(GetInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for GetInstanceRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstancesRequest { + // message fields + pub parent: ::std::string::String, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstancesRequest { + fn default() -> &'a ListInstancesRequest { + ::default_instance() + } +} + +impl ListInstancesRequest { + pub fn new() -> ListInstancesRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string page_token = 2; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstancesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.page_token.is_empty() { + os.write_string(2, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstancesRequest { + ListInstancesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListInstancesRequest| { &m.parent }, + |m: &mut ListInstancesRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListInstancesRequest| { &m.page_token }, + |m: &mut ListInstancesRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstancesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstancesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstancesRequest, + }; + unsafe { + instance.get(ListInstancesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListInstancesRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstancesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstancesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstancesResponse { + // message fields + pub instances: ::protobuf::RepeatedField, + pub failed_locations: ::protobuf::RepeatedField<::std::string::String>, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstancesResponse { + fn default() -> &'a ListInstancesResponse { + ::default_instance() + } +} + +impl ListInstancesResponse { + pub fn new() -> ListInstancesResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.Instance instances = 1; + + + pub fn get_instances(&self) -> &[super::instance::Instance] { + &self.instances + } + pub fn clear_instances(&mut self) { + self.instances.clear(); + } + + // Param is passed by value, moved + pub fn set_instances(&mut self, v: ::protobuf::RepeatedField) { + self.instances = v; + } + + // Mutable pointer to the field. + pub fn mut_instances(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.instances + } + + // Take field + pub fn take_instances(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.instances, ::protobuf::RepeatedField::new()) + } + + // repeated string failed_locations = 2; + + + pub fn get_failed_locations(&self) -> &[::std::string::String] { + &self.failed_locations + } + pub fn clear_failed_locations(&mut self) { + self.failed_locations.clear(); + } + + // Param is passed by value, moved + pub fn set_failed_locations(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.failed_locations = v; + } + + // Mutable pointer to the field. + pub fn mut_failed_locations(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.failed_locations + } + + // Take field + pub fn take_failed_locations(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.failed_locations, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 3; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstancesResponse { + fn is_initialized(&self) -> bool { + for v in &self.instances { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.instances)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.failed_locations)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.instances { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.failed_locations { + my_size += ::protobuf::rt::string_size(2, &value); + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.instances { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.failed_locations { + os.write_string(2, &v)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(3, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstancesResponse { + ListInstancesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instances", + |m: &ListInstancesResponse| { &m.instances }, + |m: &mut ListInstancesResponse| { &mut m.instances }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "failed_locations", + |m: &ListInstancesResponse| { &m.failed_locations }, + |m: &mut ListInstancesResponse| { &mut m.failed_locations }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListInstancesResponse| { &m.next_page_token }, + |m: &mut ListInstancesResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstancesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstancesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstancesResponse, + }; + unsafe { + instance.get(ListInstancesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListInstancesResponse { + fn clear(&mut self) { + self.instances.clear(); + self.failed_locations.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstancesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstancesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartialUpdateInstanceRequest { + // message fields + pub instance: ::protobuf::SingularPtrField, + pub update_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartialUpdateInstanceRequest { + fn default() -> &'a PartialUpdateInstanceRequest { + ::default_instance() + } +} + +impl PartialUpdateInstanceRequest { + pub fn new() -> PartialUpdateInstanceRequest { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.Instance instance = 1; + + + pub fn get_instance(&self) -> &super::instance::Instance { + self.instance.as_ref().unwrap_or_else(|| super::instance::Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: super::instance::Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut super::instance::Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> super::instance::Instance { + self.instance.take().unwrap_or_else(|| super::instance::Instance::new()) + } + + // .google.protobuf.FieldMask update_mask = 2; + + + pub fn get_update_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.update_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_update_mask(&mut self) { + self.update_mask.clear(); + } + + pub fn has_update_mask(&self) -> bool { + self.update_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_update_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.update_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_update_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.update_mask.is_none() { + self.update_mask.set_default(); + } + self.update_mask.as_mut().unwrap() + } + + // Take field + pub fn take_update_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.update_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } +} + +impl ::protobuf::Message for PartialUpdateInstanceRequest { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + for v in &self.update_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_mask)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.update_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.update_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartialUpdateInstanceRequest { + PartialUpdateInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &PartialUpdateInstanceRequest| { &m.instance }, + |m: &mut PartialUpdateInstanceRequest| { &mut m.instance }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "update_mask", + |m: &PartialUpdateInstanceRequest| { &m.update_mask }, + |m: &mut PartialUpdateInstanceRequest| { &mut m.update_mask }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartialUpdateInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartialUpdateInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartialUpdateInstanceRequest, + }; + unsafe { + instance.get(PartialUpdateInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for PartialUpdateInstanceRequest { + fn clear(&mut self) { + self.instance.clear(); + self.update_mask.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartialUpdateInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartialUpdateInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteInstanceRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteInstanceRequest { + fn default() -> &'a DeleteInstanceRequest { + ::default_instance() + } +} + +impl DeleteInstanceRequest { + pub fn new() -> DeleteInstanceRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteInstanceRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteInstanceRequest { + DeleteInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteInstanceRequest| { &m.name }, + |m: &mut DeleteInstanceRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteInstanceRequest, + }; + unsafe { + instance.get(DeleteInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteInstanceRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateClusterRequest { + // message fields + pub parent: ::std::string::String, + pub cluster_id: ::std::string::String, + pub cluster: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateClusterRequest { + fn default() -> &'a CreateClusterRequest { + ::default_instance() + } +} + +impl CreateClusterRequest { + pub fn new() -> CreateClusterRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string cluster_id = 2; + + + pub fn get_cluster_id(&self) -> &str { + &self.cluster_id + } + pub fn clear_cluster_id(&mut self) { + self.cluster_id.clear(); + } + + // Param is passed by value, moved + pub fn set_cluster_id(&mut self, v: ::std::string::String) { + self.cluster_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster_id(&mut self) -> &mut ::std::string::String { + &mut self.cluster_id + } + + // Take field + pub fn take_cluster_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.cluster_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Cluster cluster = 3; + + + pub fn get_cluster(&self) -> &super::instance::Cluster { + self.cluster.as_ref().unwrap_or_else(|| super::instance::Cluster::default_instance()) + } + pub fn clear_cluster(&mut self) { + self.cluster.clear(); + } + + pub fn has_cluster(&self) -> bool { + self.cluster.is_some() + } + + // Param is passed by value, moved + pub fn set_cluster(&mut self, v: super::instance::Cluster) { + self.cluster = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster(&mut self) -> &mut super::instance::Cluster { + if self.cluster.is_none() { + self.cluster.set_default(); + } + self.cluster.as_mut().unwrap() + } + + // Take field + pub fn take_cluster(&mut self) -> super::instance::Cluster { + self.cluster.take().unwrap_or_else(|| super::instance::Cluster::new()) + } +} + +impl ::protobuf::Message for CreateClusterRequest { + fn is_initialized(&self) -> bool { + for v in &self.cluster { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cluster_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cluster)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.cluster_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.cluster_id); + } + if let Some(ref v) = self.cluster.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.cluster_id.is_empty() { + os.write_string(2, &self.cluster_id)?; + } + if let Some(ref v) = self.cluster.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateClusterRequest { + CreateClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateClusterRequest| { &m.parent }, + |m: &mut CreateClusterRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "cluster_id", + |m: &CreateClusterRequest| { &m.cluster_id }, + |m: &mut CreateClusterRequest| { &mut m.cluster_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "cluster", + |m: &CreateClusterRequest| { &m.cluster }, + |m: &mut CreateClusterRequest| { &mut m.cluster }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateClusterRequest, + }; + unsafe { + instance.get(CreateClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateClusterRequest { + fn clear(&mut self) { + self.parent.clear(); + self.cluster_id.clear(); + self.cluster.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetClusterRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetClusterRequest { + fn default() -> &'a GetClusterRequest { + ::default_instance() + } +} + +impl GetClusterRequest { + pub fn new() -> GetClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetClusterRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetClusterRequest { + GetClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetClusterRequest| { &m.name }, + |m: &mut GetClusterRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetClusterRequest, + }; + unsafe { + instance.get(GetClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for GetClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListClustersRequest { + // message fields + pub parent: ::std::string::String, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListClustersRequest { + fn default() -> &'a ListClustersRequest { + ::default_instance() + } +} + +impl ListClustersRequest { + pub fn new() -> ListClustersRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string page_token = 2; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListClustersRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.page_token.is_empty() { + os.write_string(2, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListClustersRequest { + ListClustersRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListClustersRequest| { &m.parent }, + |m: &mut ListClustersRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListClustersRequest| { &m.page_token }, + |m: &mut ListClustersRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListClustersRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListClustersRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListClustersRequest, + }; + unsafe { + instance.get(ListClustersRequest::new) + } + } +} + +impl ::protobuf::Clear for ListClustersRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListClustersRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListClustersRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListClustersResponse { + // message fields + pub clusters: ::protobuf::RepeatedField, + pub failed_locations: ::protobuf::RepeatedField<::std::string::String>, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListClustersResponse { + fn default() -> &'a ListClustersResponse { + ::default_instance() + } +} + +impl ListClustersResponse { + pub fn new() -> ListClustersResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.Cluster clusters = 1; + + + pub fn get_clusters(&self) -> &[super::instance::Cluster] { + &self.clusters + } + pub fn clear_clusters(&mut self) { + self.clusters.clear(); + } + + // Param is passed by value, moved + pub fn set_clusters(&mut self, v: ::protobuf::RepeatedField) { + self.clusters = v; + } + + // Mutable pointer to the field. + pub fn mut_clusters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.clusters + } + + // Take field + pub fn take_clusters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.clusters, ::protobuf::RepeatedField::new()) + } + + // repeated string failed_locations = 2; + + + pub fn get_failed_locations(&self) -> &[::std::string::String] { + &self.failed_locations + } + pub fn clear_failed_locations(&mut self) { + self.failed_locations.clear(); + } + + // Param is passed by value, moved + pub fn set_failed_locations(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.failed_locations = v; + } + + // Mutable pointer to the field. + pub fn mut_failed_locations(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.failed_locations + } + + // Take field + pub fn take_failed_locations(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.failed_locations, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 3; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListClustersResponse { + fn is_initialized(&self) -> bool { + for v in &self.clusters { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.clusters)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.failed_locations)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.clusters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.failed_locations { + my_size += ::protobuf::rt::string_size(2, &value); + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.clusters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.failed_locations { + os.write_string(2, &v)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(3, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListClustersResponse { + ListClustersResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "clusters", + |m: &ListClustersResponse| { &m.clusters }, + |m: &mut ListClustersResponse| { &mut m.clusters }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "failed_locations", + |m: &ListClustersResponse| { &m.failed_locations }, + |m: &mut ListClustersResponse| { &mut m.failed_locations }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListClustersResponse| { &m.next_page_token }, + |m: &mut ListClustersResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListClustersResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListClustersResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListClustersResponse, + }; + unsafe { + instance.get(ListClustersResponse::new) + } + } +} + +impl ::protobuf::Clear for ListClustersResponse { + fn clear(&mut self) { + self.clusters.clear(); + self.failed_locations.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListClustersResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListClustersResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteClusterRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteClusterRequest { + fn default() -> &'a DeleteClusterRequest { + ::default_instance() + } +} + +impl DeleteClusterRequest { + pub fn new() -> DeleteClusterRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteClusterRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteClusterRequest { + DeleteClusterRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteClusterRequest| { &m.name }, + |m: &mut DeleteClusterRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteClusterRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteClusterRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteClusterRequest, + }; + unsafe { + instance.get(DeleteClusterRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteClusterRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteClusterRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteClusterRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateInstanceMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateInstanceMetadata { + fn default() -> &'a CreateInstanceMetadata { + ::default_instance() + } +} + +impl CreateInstanceMetadata { + pub fn new() -> CreateInstanceMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.CreateInstanceRequest original_request = 1; + + + pub fn get_original_request(&self) -> &CreateInstanceRequest { + self.original_request.as_ref().unwrap_or_else(|| CreateInstanceRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: CreateInstanceRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut CreateInstanceRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> CreateInstanceRequest { + self.original_request.take().unwrap_or_else(|| CreateInstanceRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CreateInstanceMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateInstanceMetadata { + CreateInstanceMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &CreateInstanceMetadata| { &m.original_request }, + |m: &mut CreateInstanceMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &CreateInstanceMetadata| { &m.request_time }, + |m: &mut CreateInstanceMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &CreateInstanceMetadata| { &m.finish_time }, + |m: &mut CreateInstanceMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateInstanceMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateInstanceMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateInstanceMetadata, + }; + unsafe { + instance.get(CreateInstanceMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateInstanceMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateInstanceMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateInstanceMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateInstanceMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateInstanceMetadata { + fn default() -> &'a UpdateInstanceMetadata { + ::default_instance() + } +} + +impl UpdateInstanceMetadata { + pub fn new() -> UpdateInstanceMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.PartialUpdateInstanceRequest original_request = 1; + + + pub fn get_original_request(&self) -> &PartialUpdateInstanceRequest { + self.original_request.as_ref().unwrap_or_else(|| PartialUpdateInstanceRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: PartialUpdateInstanceRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut PartialUpdateInstanceRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> PartialUpdateInstanceRequest { + self.original_request.take().unwrap_or_else(|| PartialUpdateInstanceRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for UpdateInstanceMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateInstanceMetadata { + UpdateInstanceMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &UpdateInstanceMetadata| { &m.original_request }, + |m: &mut UpdateInstanceMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &UpdateInstanceMetadata| { &m.request_time }, + |m: &mut UpdateInstanceMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &UpdateInstanceMetadata| { &m.finish_time }, + |m: &mut UpdateInstanceMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateInstanceMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateInstanceMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateInstanceMetadata, + }; + unsafe { + instance.get(UpdateInstanceMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateInstanceMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateInstanceMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateInstanceMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateClusterMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateClusterMetadata { + fn default() -> &'a CreateClusterMetadata { + ::default_instance() + } +} + +impl CreateClusterMetadata { + pub fn new() -> CreateClusterMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.CreateClusterRequest original_request = 1; + + + pub fn get_original_request(&self) -> &CreateClusterRequest { + self.original_request.as_ref().unwrap_or_else(|| CreateClusterRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: CreateClusterRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut CreateClusterRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> CreateClusterRequest { + self.original_request.take().unwrap_or_else(|| CreateClusterRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CreateClusterMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateClusterMetadata { + CreateClusterMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &CreateClusterMetadata| { &m.original_request }, + |m: &mut CreateClusterMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &CreateClusterMetadata| { &m.request_time }, + |m: &mut CreateClusterMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &CreateClusterMetadata| { &m.finish_time }, + |m: &mut CreateClusterMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateClusterMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateClusterMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateClusterMetadata, + }; + unsafe { + instance.get(CreateClusterMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateClusterMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateClusterMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateClusterMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateClusterMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateClusterMetadata { + fn default() -> &'a UpdateClusterMetadata { + ::default_instance() + } +} + +impl UpdateClusterMetadata { + pub fn new() -> UpdateClusterMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.Cluster original_request = 1; + + + pub fn get_original_request(&self) -> &super::instance::Cluster { + self.original_request.as_ref().unwrap_or_else(|| super::instance::Cluster::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: super::instance::Cluster) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut super::instance::Cluster { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> super::instance::Cluster { + self.original_request.take().unwrap_or_else(|| super::instance::Cluster::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for UpdateClusterMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateClusterMetadata { + UpdateClusterMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &UpdateClusterMetadata| { &m.original_request }, + |m: &mut UpdateClusterMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &UpdateClusterMetadata| { &m.request_time }, + |m: &mut UpdateClusterMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &UpdateClusterMetadata| { &m.finish_time }, + |m: &mut UpdateClusterMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateClusterMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateClusterMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateClusterMetadata, + }; + unsafe { + instance.get(UpdateClusterMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateClusterMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateClusterMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateClusterMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateAppProfileRequest { + // message fields + pub parent: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub app_profile: ::protobuf::SingularPtrField, + pub ignore_warnings: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateAppProfileRequest { + fn default() -> &'a CreateAppProfileRequest { + ::default_instance() + } +} + +impl CreateAppProfileRequest { + pub fn new() -> CreateAppProfileRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string app_profile_id = 2; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.AppProfile app_profile = 3; + + + pub fn get_app_profile(&self) -> &super::instance::AppProfile { + self.app_profile.as_ref().unwrap_or_else(|| super::instance::AppProfile::default_instance()) + } + pub fn clear_app_profile(&mut self) { + self.app_profile.clear(); + } + + pub fn has_app_profile(&self) -> bool { + self.app_profile.is_some() + } + + // Param is passed by value, moved + pub fn set_app_profile(&mut self, v: super::instance::AppProfile) { + self.app_profile = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile(&mut self) -> &mut super::instance::AppProfile { + if self.app_profile.is_none() { + self.app_profile.set_default(); + } + self.app_profile.as_mut().unwrap() + } + + // Take field + pub fn take_app_profile(&mut self) -> super::instance::AppProfile { + self.app_profile.take().unwrap_or_else(|| super::instance::AppProfile::new()) + } + + // bool ignore_warnings = 4; + + + pub fn get_ignore_warnings(&self) -> bool { + self.ignore_warnings + } + pub fn clear_ignore_warnings(&mut self) { + self.ignore_warnings = false; + } + + // Param is passed by value, moved + pub fn set_ignore_warnings(&mut self, v: bool) { + self.ignore_warnings = v; + } +} + +impl ::protobuf::Message for CreateAppProfileRequest { + fn is_initialized(&self) -> bool { + for v in &self.app_profile { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.app_profile)?; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.ignore_warnings = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.app_profile_id); + } + if let Some(ref v) = self.app_profile.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.ignore_warnings != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(2, &self.app_profile_id)?; + } + if let Some(ref v) = self.app_profile.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.ignore_warnings != false { + os.write_bool(4, self.ignore_warnings)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateAppProfileRequest { + CreateAppProfileRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateAppProfileRequest| { &m.parent }, + |m: &mut CreateAppProfileRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &CreateAppProfileRequest| { &m.app_profile_id }, + |m: &mut CreateAppProfileRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "app_profile", + |m: &CreateAppProfileRequest| { &m.app_profile }, + |m: &mut CreateAppProfileRequest| { &mut m.app_profile }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "ignore_warnings", + |m: &CreateAppProfileRequest| { &m.ignore_warnings }, + |m: &mut CreateAppProfileRequest| { &mut m.ignore_warnings }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateAppProfileRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateAppProfileRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateAppProfileRequest, + }; + unsafe { + instance.get(CreateAppProfileRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateAppProfileRequest { + fn clear(&mut self) { + self.parent.clear(); + self.app_profile_id.clear(); + self.app_profile.clear(); + self.ignore_warnings = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateAppProfileRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateAppProfileRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetAppProfileRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetAppProfileRequest { + fn default() -> &'a GetAppProfileRequest { + ::default_instance() + } +} + +impl GetAppProfileRequest { + pub fn new() -> GetAppProfileRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetAppProfileRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetAppProfileRequest { + GetAppProfileRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetAppProfileRequest| { &m.name }, + |m: &mut GetAppProfileRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetAppProfileRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetAppProfileRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetAppProfileRequest, + }; + unsafe { + instance.get(GetAppProfileRequest::new) + } + } +} + +impl ::protobuf::Clear for GetAppProfileRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetAppProfileRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetAppProfileRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListAppProfilesRequest { + // message fields + pub parent: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListAppProfilesRequest { + fn default() -> &'a ListAppProfilesRequest { + ::default_instance() + } +} + +impl ListAppProfilesRequest { + pub fn new() -> ListAppProfilesRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // int32 page_size = 3; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 2; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListAppProfilesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(3, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.page_size != 0 { + os.write_int32(3, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(2, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListAppProfilesRequest { + ListAppProfilesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListAppProfilesRequest| { &m.parent }, + |m: &mut ListAppProfilesRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListAppProfilesRequest| { &m.page_size }, + |m: &mut ListAppProfilesRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListAppProfilesRequest| { &m.page_token }, + |m: &mut ListAppProfilesRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListAppProfilesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListAppProfilesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListAppProfilesRequest, + }; + unsafe { + instance.get(ListAppProfilesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListAppProfilesRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListAppProfilesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListAppProfilesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListAppProfilesResponse { + // message fields + pub app_profiles: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + pub failed_locations: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListAppProfilesResponse { + fn default() -> &'a ListAppProfilesResponse { + ::default_instance() + } +} + +impl ListAppProfilesResponse { + pub fn new() -> ListAppProfilesResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.AppProfile app_profiles = 1; + + + pub fn get_app_profiles(&self) -> &[super::instance::AppProfile] { + &self.app_profiles + } + pub fn clear_app_profiles(&mut self) { + self.app_profiles.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profiles(&mut self, v: ::protobuf::RepeatedField) { + self.app_profiles = v; + } + + // Mutable pointer to the field. + pub fn mut_app_profiles(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.app_profiles + } + + // Take field + pub fn take_app_profiles(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.app_profiles, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } + + // repeated string failed_locations = 3; + + + pub fn get_failed_locations(&self) -> &[::std::string::String] { + &self.failed_locations + } + pub fn clear_failed_locations(&mut self) { + self.failed_locations.clear(); + } + + // Param is passed by value, moved + pub fn set_failed_locations(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.failed_locations = v; + } + + // Mutable pointer to the field. + pub fn mut_failed_locations(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.failed_locations + } + + // Take field + pub fn take_failed_locations(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.failed_locations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ListAppProfilesResponse { + fn is_initialized(&self) -> bool { + for v in &self.app_profiles { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.app_profiles)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.failed_locations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.app_profiles { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + for value in &self.failed_locations { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.app_profiles { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + for v in &self.failed_locations { + os.write_string(3, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListAppProfilesResponse { + ListAppProfilesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "app_profiles", + |m: &ListAppProfilesResponse| { &m.app_profiles }, + |m: &mut ListAppProfilesResponse| { &mut m.app_profiles }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListAppProfilesResponse| { &m.next_page_token }, + |m: &mut ListAppProfilesResponse| { &mut m.next_page_token }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "failed_locations", + |m: &ListAppProfilesResponse| { &m.failed_locations }, + |m: &mut ListAppProfilesResponse| { &mut m.failed_locations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListAppProfilesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListAppProfilesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListAppProfilesResponse, + }; + unsafe { + instance.get(ListAppProfilesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListAppProfilesResponse { + fn clear(&mut self) { + self.app_profiles.clear(); + self.next_page_token.clear(); + self.failed_locations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListAppProfilesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListAppProfilesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateAppProfileRequest { + // message fields + pub app_profile: ::protobuf::SingularPtrField, + pub update_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + pub ignore_warnings: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateAppProfileRequest { + fn default() -> &'a UpdateAppProfileRequest { + ::default_instance() + } +} + +impl UpdateAppProfileRequest { + pub fn new() -> UpdateAppProfileRequest { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.AppProfile app_profile = 1; + + + pub fn get_app_profile(&self) -> &super::instance::AppProfile { + self.app_profile.as_ref().unwrap_or_else(|| super::instance::AppProfile::default_instance()) + } + pub fn clear_app_profile(&mut self) { + self.app_profile.clear(); + } + + pub fn has_app_profile(&self) -> bool { + self.app_profile.is_some() + } + + // Param is passed by value, moved + pub fn set_app_profile(&mut self, v: super::instance::AppProfile) { + self.app_profile = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile(&mut self) -> &mut super::instance::AppProfile { + if self.app_profile.is_none() { + self.app_profile.set_default(); + } + self.app_profile.as_mut().unwrap() + } + + // Take field + pub fn take_app_profile(&mut self) -> super::instance::AppProfile { + self.app_profile.take().unwrap_or_else(|| super::instance::AppProfile::new()) + } + + // .google.protobuf.FieldMask update_mask = 2; + + + pub fn get_update_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.update_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_update_mask(&mut self) { + self.update_mask.clear(); + } + + pub fn has_update_mask(&self) -> bool { + self.update_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_update_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.update_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_update_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.update_mask.is_none() { + self.update_mask.set_default(); + } + self.update_mask.as_mut().unwrap() + } + + // Take field + pub fn take_update_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.update_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } + + // bool ignore_warnings = 3; + + + pub fn get_ignore_warnings(&self) -> bool { + self.ignore_warnings + } + pub fn clear_ignore_warnings(&mut self) { + self.ignore_warnings = false; + } + + // Param is passed by value, moved + pub fn set_ignore_warnings(&mut self, v: bool) { + self.ignore_warnings = v; + } +} + +impl ::protobuf::Message for UpdateAppProfileRequest { + fn is_initialized(&self) -> bool { + for v in &self.app_profile { + if !v.is_initialized() { + return false; + } + }; + for v in &self.update_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.app_profile)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_mask)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.ignore_warnings = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.app_profile.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.update_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.ignore_warnings != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.app_profile.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.update_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.ignore_warnings != false { + os.write_bool(3, self.ignore_warnings)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateAppProfileRequest { + UpdateAppProfileRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "app_profile", + |m: &UpdateAppProfileRequest| { &m.app_profile }, + |m: &mut UpdateAppProfileRequest| { &mut m.app_profile }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "update_mask", + |m: &UpdateAppProfileRequest| { &m.update_mask }, + |m: &mut UpdateAppProfileRequest| { &mut m.update_mask }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "ignore_warnings", + |m: &UpdateAppProfileRequest| { &m.ignore_warnings }, + |m: &mut UpdateAppProfileRequest| { &mut m.ignore_warnings }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateAppProfileRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateAppProfileRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateAppProfileRequest, + }; + unsafe { + instance.get(UpdateAppProfileRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateAppProfileRequest { + fn clear(&mut self) { + self.app_profile.clear(); + self.update_mask.clear(); + self.ignore_warnings = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateAppProfileRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateAppProfileRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteAppProfileRequest { + // message fields + pub name: ::std::string::String, + pub ignore_warnings: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteAppProfileRequest { + fn default() -> &'a DeleteAppProfileRequest { + ::default_instance() + } +} + +impl DeleteAppProfileRequest { + pub fn new() -> DeleteAppProfileRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // bool ignore_warnings = 2; + + + pub fn get_ignore_warnings(&self) -> bool { + self.ignore_warnings + } + pub fn clear_ignore_warnings(&mut self) { + self.ignore_warnings = false; + } + + // Param is passed by value, moved + pub fn set_ignore_warnings(&mut self, v: bool) { + self.ignore_warnings = v; + } +} + +impl ::protobuf::Message for DeleteAppProfileRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.ignore_warnings = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if self.ignore_warnings != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if self.ignore_warnings != false { + os.write_bool(2, self.ignore_warnings)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteAppProfileRequest { + DeleteAppProfileRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteAppProfileRequest| { &m.name }, + |m: &mut DeleteAppProfileRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "ignore_warnings", + |m: &DeleteAppProfileRequest| { &m.ignore_warnings }, + |m: &mut DeleteAppProfileRequest| { &mut m.ignore_warnings }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteAppProfileRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteAppProfileRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteAppProfileRequest, + }; + unsafe { + instance.get(DeleteAppProfileRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteAppProfileRequest { + fn clear(&mut self) { + self.name.clear(); + self.ignore_warnings = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteAppProfileRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteAppProfileRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateAppProfileMetadata { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateAppProfileMetadata { + fn default() -> &'a UpdateAppProfileMetadata { + ::default_instance() + } +} + +impl UpdateAppProfileMetadata { + pub fn new() -> UpdateAppProfileMetadata { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for UpdateAppProfileMetadata { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateAppProfileMetadata { + UpdateAppProfileMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateAppProfileMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateAppProfileMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateAppProfileMetadata, + }; + unsafe { + instance.get(UpdateAppProfileMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateAppProfileMetadata { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateAppProfileMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateAppProfileMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n6google/bigtable/admin/v2/bigtable_instance_admin.proto\x12\x18google.\ + bigtable.admin.v2\x1a\x1cgoogle/api/annotations.proto\x1a'google/bigtabl\ + e/admin/v2/instance.proto\x1a\x1egoogle/iam/v1/iam_policy.proto\x1a\x1ag\ + oogle/iam/v1/policy.proto\x1a#google/longrunning/operations.proto\x1a\ + \x1bgoogle/protobuf/empty.proto\x1a\x20google/protobuf/field_mask.proto\ + \x1a\x1fgoogle/protobuf/timestamp.proto\"\xcb\x02\n\x15CreateInstanceReq\ + uest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x1f\n\x0binst\ + ance_id\x18\x02\x20\x01(\tR\ninstanceId\x12>\n\x08instance\x18\x03\x20\ + \x01(\x0b2\".google.bigtable.admin.v2.InstanceR\x08instance\x12Y\n\x08cl\ + usters\x18\x04\x20\x03(\x0b2=.google.bigtable.admin.v2.CreateInstanceReq\ + uest.ClustersEntryR\x08clusters\x1a^\n\rClustersEntry\x12\x10\n\x03key\ + \x18\x01\x20\x01(\tR\x03key\x127\n\x05value\x18\x02\x20\x01(\x0b2!.googl\ + e.bigtable.admin.v2.ClusterR\x05value:\x028\x01\"(\n\x12GetInstanceReque\ + st\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"M\n\x14ListInstancesRe\ + quest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x1d\n\npage_\ + token\x18\x02\x20\x01(\tR\tpageToken\"\xac\x01\n\x15ListInstancesRespons\ + e\x12@\n\tinstances\x18\x01\x20\x03(\x0b2\".google.bigtable.admin.v2.Ins\ + tanceR\tinstances\x12)\n\x10failed_locations\x18\x02\x20\x03(\tR\x0ffail\ + edLocations\x12&\n\x0fnext_page_token\x18\x03\x20\x01(\tR\rnextPageToken\ + \"\x9b\x01\n\x1cPartialUpdateInstanceRequest\x12>\n\x08instance\x18\x01\ + \x20\x01(\x0b2\".google.bigtable.admin.v2.InstanceR\x08instance\x12;\n\ + \x0bupdate_mask\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.FieldMaskR\nup\ + dateMask\"+\n\x15DeleteInstanceRequest\x12\x12\n\x04name\x18\x01\x20\x01\ + (\tR\x04name\"\x8a\x01\n\x14CreateClusterRequest\x12\x16\n\x06parent\x18\ + \x01\x20\x01(\tR\x06parent\x12\x1d\n\ncluster_id\x18\x02\x20\x01(\tR\tcl\ + usterId\x12;\n\x07cluster\x18\x03\x20\x01(\x0b2!.google.bigtable.admin.v\ + 2.ClusterR\x07cluster\"'\n\x11GetClusterRequest\x12\x12\n\x04name\x18\ + \x01\x20\x01(\tR\x04name\"L\n\x13ListClustersRequest\x12\x16\n\x06parent\ + \x18\x01\x20\x01(\tR\x06parent\x12\x1d\n\npage_token\x18\x02\x20\x01(\tR\ + \tpageToken\"\xa8\x01\n\x14ListClustersResponse\x12=\n\x08clusters\x18\ + \x01\x20\x03(\x0b2!.google.bigtable.admin.v2.ClusterR\x08clusters\x12)\n\ + \x10failed_locations\x18\x02\x20\x03(\tR\x0ffailedLocations\x12&\n\x0fne\ + xt_page_token\x18\x03\x20\x01(\tR\rnextPageToken\"*\n\x14DeleteClusterRe\ + quest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\xf0\x01\n\x16Creat\ + eInstanceMetadata\x12Z\n\x10original_request\x18\x01\x20\x01(\x0b2/.goog\ + le.bigtable.admin.v2.CreateInstanceRequestR\x0foriginalRequest\x12=\n\ + \x0crequest_time\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ + \x0brequestTime\x12;\n\x0bfinish_time\x18\x03\x20\x01(\x0b2\x1a.google.p\ + rotobuf.TimestampR\nfinishTime\"\xf7\x01\n\x16UpdateInstanceMetadata\x12\ + a\n\x10original_request\x18\x01\x20\x01(\x0b26.google.bigtable.admin.v2.\ + PartialUpdateInstanceRequestR\x0foriginalRequest\x12=\n\x0crequest_time\ + \x18\x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\x0brequestTime\x12\ + ;\n\x0bfinish_time\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ + \nfinishTime\"\xee\x01\n\x15CreateClusterMetadata\x12Y\n\x10original_req\ + uest\x18\x01\x20\x01(\x0b2..google.bigtable.admin.v2.CreateClusterReques\ + tR\x0foriginalRequest\x12=\n\x0crequest_time\x18\x02\x20\x01(\x0b2\x1a.g\ + oogle.protobuf.TimestampR\x0brequestTime\x12;\n\x0bfinish_time\x18\x03\ + \x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nfinishTime\"\xe1\x01\n\ + \x15UpdateClusterMetadata\x12L\n\x10original_request\x18\x01\x20\x01(\ + \x0b2!.google.bigtable.admin.v2.ClusterR\x0foriginalRequest\x12=\n\x0cre\ + quest_time\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\x0breque\ + stTime\x12;\n\x0bfinish_time\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.T\ + imestampR\nfinishTime\"\xc7\x01\n\x17CreateAppProfileRequest\x12\x16\n\ + \x06parent\x18\x01\x20\x01(\tR\x06parent\x12$\n\x0eapp_profile_id\x18\ + \x02\x20\x01(\tR\x0cappProfileId\x12E\n\x0bapp_profile\x18\x03\x20\x01(\ + \x0b2$.google.bigtable.admin.v2.AppProfileR\nappProfile\x12'\n\x0fignore\ + _warnings\x18\x04\x20\x01(\x08R\x0eignoreWarnings\"*\n\x14GetAppProfileR\ + equest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"l\n\x16ListAppProf\ + ilesRequest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x1b\n\ + \tpage_size\x18\x03\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\ + \x02\x20\x01(\tR\tpageToken\"\xb5\x01\n\x17ListAppProfilesResponse\x12G\ + \n\x0capp_profiles\x18\x01\x20\x03(\x0b2$.google.bigtable.admin.v2.AppPr\ + ofileR\x0bappProfiles\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnex\ + tPageToken\x12)\n\x10failed_locations\x18\x03\x20\x03(\tR\x0ffailedLocat\ + ions\"\xc6\x01\n\x17UpdateAppProfileRequest\x12E\n\x0bapp_profile\x18\ + \x01\x20\x01(\x0b2$.google.bigtable.admin.v2.AppProfileR\nappProfile\x12\ + ;\n\x0bupdate_mask\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.FieldMaskR\ + \nupdateMask\x12'\n\x0fignore_warnings\x18\x03\x20\x01(\x08R\x0eignoreWa\ + rnings\"V\n\x17DeleteAppProfileRequest\x12\x12\n\x04name\x18\x01\x20\x01\ + (\tR\x04name\x12'\n\x0fignore_warnings\x18\x02\x20\x01(\x08R\x0eignoreWa\ + rnings\"\x1a\n\x18UpdateAppProfileMetadata2\xaa\x17\n\x15BigtableInstanc\ + eAdmin\x12\x8e\x01\n\x0eCreateInstance\x12/.google.bigtable.admin.v2.Cre\ + ateInstanceRequest\x1a\x1d.google.longrunning.Operation\",\x82\xd3\xe4\ + \x93\x02&\"!/v2/{parent=projects/*}/instances:\x01*\x12\x8a\x01\n\x0bGet\ + Instance\x12,.google.bigtable.admin.v2.GetInstanceRequest\x1a\".google.b\ + igtable.admin.v2.Instance\")\x82\xd3\xe4\x93\x02#\x12!/v2/{name=projects\ + /*/instances/*}\x12\x9b\x01\n\rListInstances\x12..google.bigtable.admin.\ + v2.ListInstancesRequest\x1a/.google.bigtable.admin.v2.ListInstancesRespo\ + nse\")\x82\xd3\xe4\x93\x02#\x12!/v2/{parent=projects/*}/instances\x12\ + \x86\x01\n\x0eUpdateInstance\x12\".google.bigtable.admin.v2.Instance\x1a\ + \".google.bigtable.admin.v2.Instance\",\x82\xd3\xe4\x93\x02&\x1a!/v2/{na\ + me=projects/*/instances/*}:\x01*\x12\xac\x01\n\x15PartialUpdateInstance\ + \x126.google.bigtable.admin.v2.PartialUpdateInstanceRequest\x1a\x1d.goog\ + le.longrunning.Operation\"<\x82\xd3\xe4\x93\x0262*/v2/{instance.name=pro\ + jects/*/instances/*}:\x08instance\x12\x84\x01\n\x0eDeleteInstance\x12/.g\ + oogle.bigtable.admin.v2.DeleteInstanceRequest\x1a\x16.google.protobuf.Em\ + pty\")\x82\xd3\xe4\x93\x02#*!/v2/{name=projects/*/instances/*}\x12\x9d\ + \x01\n\rCreateCluster\x12..google.bigtable.admin.v2.CreateClusterRequest\ + \x1a\x1d.google.longrunning.Operation\"=\x82\xd3\xe4\x93\x027\",/v2/{par\ + ent=projects/*/instances/*}/clusters:\x07cluster\x12\x92\x01\n\nGetClust\ + er\x12+.google.bigtable.admin.v2.GetClusterRequest\x1a!.google.bigtable.\ + admin.v2.Cluster\"4\x82\xd3\xe4\x93\x02.\x12,/v2/{name=projects/*/instan\ + ces/*/clusters/*}\x12\xa3\x01\n\x0cListClusters\x12-.google.bigtable.adm\ + in.v2.ListClustersRequest\x1a..google.bigtable.admin.v2.ListClustersResp\ + onse\"4\x82\xd3\xe4\x93\x02.\x12,/v2/{parent=projects/*/instances/*}/clu\ + sters\x12\x8a\x01\n\rUpdateCluster\x12!.google.bigtable.admin.v2.Cluster\ + \x1a\x1d.google.longrunning.Operation\"7\x82\xd3\xe4\x93\x021\x1a,/v2/{n\ + ame=projects/*/instances/*/clusters/*}:\x01*\x12\x8d\x01\n\rDeleteCluste\ + r\x12..google.bigtable.admin.v2.DeleteClusterRequest\x1a\x16.google.prot\ + obuf.Empty\"4\x82\xd3\xe4\x93\x02.*,/v2/{name=projects/*/instances/*/clu\ + sters/*}\x12\xb1\x01\n\x10CreateAppProfile\x121.google.bigtable.admin.v2\ + .CreateAppProfileRequest\x1a$.google.bigtable.admin.v2.AppProfile\"D\x82\ + \xd3\xe4\x93\x02>\"//v2/{parent=projects/*/instances/*}/appProfiles:\x0b\ + app_profile\x12\x9e\x01\n\rGetAppProfile\x12..google.bigtable.admin.v2.G\ + etAppProfileRequest\x1a$.google.bigtable.admin.v2.AppProfile\"7\x82\xd3\ + \xe4\x93\x021\x12//v2/{name=projects/*/instances/*/appProfiles/*}\x12\ + \xaf\x01\n\x0fListAppProfiles\x120.google.bigtable.admin.v2.ListAppProfi\ + lesRequest\x1a1.google.bigtable.admin.v2.ListAppProfilesResponse\"7\x82\ + \xd3\xe4\x93\x021\x12//v2/{parent=projects/*/instances/*}/appProfiles\ + \x12\xb6\x01\n\x10UpdateAppProfile\x121.google.bigtable.admin.v2.UpdateA\ + ppProfileRequest\x1a\x1d.google.longrunning.Operation\"P\x82\xd3\xe4\x93\ + \x02J2;/v2/{app_profile.name=projects/*/instances/*/appProfiles/*}:\x0ba\ + pp_profile\x12\x96\x01\n\x10DeleteAppProfile\x121.google.bigtable.admin.\ + v2.DeleteAppProfileRequest\x1a\x16.google.protobuf.Empty\"7\x82\xd3\xe4\ + \x93\x021*//v2/{name=projects/*/instances/*/appProfiles/*}\x12\x88\x01\n\ + \x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRequest\x1a\x15.google.\ + iam.v1.Policy\"=\x82\xd3\xe4\x93\x027\"2/v2/{resource=projects/*/instanc\ + es/*}:getIamPolicy:\x01*\x12\x88\x01\n\x0cSetIamPolicy\x12\".google.iam.\ + v1.SetIamPolicyRequest\x1a\x15.google.iam.v1.Policy\"=\x82\xd3\xe4\x93\ + \x027\"2/v2/{resource=projects/*/instances/*}:setIamPolicy:\x01*\x12\xae\ + \x01\n\x12TestIamPermissions\x12(.google.iam.v1.TestIamPermissionsReques\ + t\x1a).google.iam.v1.TestIamPermissionsResponse\"C\x82\xd3\xe4\x93\x02=\ + \"8/v2/{resource=projects/*/instances/*}:testIamPermissions:\x01*B\xbd\ + \x01\n\x1ccom.google.bigtable.admin.v2B\x1aBigtableInstanceAdminProtoP\ + \x01Z=google.golang.org/genproto/googleapis/bigtable/admin/v2;admin\xaa\ + \x02\x1eGoogle.Cloud.Bigtable.Admin.V2\xca\x02\x1eGoogle\\Cloud\\Bigtabl\ + e\\Admin\\V2J\xbex\n\x07\x12\x05\x0f\0\xc7\x03\x01\n\xbe\x04\n\x01\x0c\ + \x12\x03\x0f\0\x122\xb3\x04\x20Copyright\x202018\x20Google\x20LLC.\n\n\ + \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\ + (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\ + xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\ + obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\ + \x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\ + \x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\ + oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\ + \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\ + \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\ + ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\ + governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\ + nse.\n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\t\n\x02\x03\0\x12\x03\x13\0&\n\ + \t\n\x02\x03\x01\x12\x03\x14\01\n\t\n\x02\x03\x02\x12\x03\x15\0(\n\t\n\ + \x02\x03\x03\x12\x03\x16\0$\n\t\n\x02\x03\x04\x12\x03\x17\0-\n\t\n\x02\ + \x03\x05\x12\x03\x18\0%\n\t\n\x02\x03\x06\x12\x03\x19\0*\n\t\n\x02\x03\ + \x07\x12\x03\x1a\0)\n\x08\n\x01\x08\x12\x03\x1c\0;\n\t\n\x02\x08%\x12\ + \x03\x1c\0;\n\x08\n\x01\x08\x12\x03\x1d\0T\n\t\n\x02\x08\x0b\x12\x03\x1d\ + \0T\n\x08\n\x01\x08\x12\x03\x1e\0\"\n\t\n\x02\x08\n\x12\x03\x1e\0\"\n\ + \x08\n\x01\x08\x12\x03\x1f\0;\n\t\n\x02\x08\x08\x12\x03\x1f\0;\n\x08\n\ + \x01\x08\x12\x03\x20\05\n\t\n\x02\x08\x01\x12\x03\x20\05\n\x08\n\x01\x08\ + \x12\x03!\0<\n\t\n\x02\x08)\x12\x03!\0<\n\xdb\x01\n\x02\x06\0\x12\x05'\0\ + \xb8\x01\x01\x1a\xcd\x01\x20Service\x20for\x20creating,\x20configuring,\ + \x20and\x20deleting\x20Cloud\x20Bigtable\x20Instances\x20and\n\x20Cluste\ + rs.\x20Provides\x20access\x20to\x20the\x20Instance\x20and\x20Cluster\x20\ + schemas\x20only,\x20not\x20the\n\x20tables'\x20metadata\x20or\x20data\ + \x20stored\x20in\x20those\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03'\x08\ + \x1d\n4\n\x04\x06\0\x02\0\x12\x04)\x02.\x03\x1a&\x20Create\x20an\x20inst\ + ance\x20within\x20a\x20project.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03)\ + \x06\x14\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03)\x15*\n\x0c\n\x05\x06\0\x02\ + \0\x03\x12\x03)5Q\n\r\n\x05\x06\0\x02\0\x04\x12\x04*\x04-\x06\n\x11\n\t\ + \x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04*\x04-\x06\n3\n\x04\x06\0\x02\x01\ + \x12\x041\x025\x03\x1a%\x20Gets\x20information\x20about\x20an\x20instanc\ + e.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x031\x06\x11\n\x0c\n\x05\x06\0\ + \x02\x01\x02\x12\x031\x12$\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x031/7\n\r\ + \n\x05\x06\0\x02\x01\x04\x12\x042\x044\x06\n\x11\n\t\x06\0\x02\x01\x04\ + \xb0\xca\xbc\"\x12\x042\x044\x06\n?\n\x04\x06\0\x02\x02\x12\x048\x02<\ + \x03\x1a1\x20Lists\x20information\x20about\x20instances\x20in\x20a\x20pr\ + oject.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x038\x06\x13\n\x0c\n\x05\x06\ + \0\x02\x02\x02\x12\x038\x14(\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x0383H\n\ + \r\n\x05\x06\0\x02\x02\x04\x12\x049\x04;\x06\n\x11\n\t\x06\0\x02\x02\x04\ + \xb0\xca\xbc\"\x12\x049\x04;\x06\n5\n\x04\x06\0\x02\x03\x12\x04?\x02D\ + \x03\x1a'\x20Updates\x20an\x20instance\x20within\x20a\x20project.\n\n\ + \x0c\n\x05\x06\0\x02\x03\x01\x12\x03?\x06\x14\n\x0c\n\x05\x06\0\x02\x03\ + \x02\x12\x03?\x15\x1d\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03?(0\n\r\n\x05\ + \x06\0\x02\x03\x04\x12\x04@\x04C\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\ + \xbc\"\x12\x04@\x04C\x06\n?\n\x04\x06\0\x02\x04\x12\x04G\x02L\x03\x1a1\ + \x20Partially\x20updates\x20an\x20instance\x20within\x20a\x20project.\n\ + \n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03G\x06\x1b\n\x0c\n\x05\x06\0\x02\ + \x04\x02\x12\x03G\x1c8\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03GC_\n\r\n\ + \x05\x06\0\x02\x04\x04\x12\x04H\x04K\x06\n\x11\n\t\x06\0\x02\x04\x04\xb0\ + \xca\xbc\"\x12\x04H\x04K\x06\n2\n\x04\x06\0\x02\x05\x12\x04O\x02S\x03\ + \x1a$\x20Delete\x20an\x20instance\x20from\x20a\x20project.\n\n\x0c\n\x05\ + \x06\0\x02\x05\x01\x12\x03O\x06\x14\n\x0c\n\x05\x06\0\x02\x05\x02\x12\ + \x03O\x15*\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03O5J\n\r\n\x05\x06\0\x02\ + \x05\x04\x12\x04P\x04R\x06\n\x11\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\"\x12\ + \x04P\x04R\x06\n5\n\x04\x06\0\x02\x06\x12\x04V\x02[\x03\x1a'\x20Creates\ + \x20a\x20cluster\x20within\x20an\x20instance.\n\n\x0c\n\x05\x06\0\x02\ + \x06\x01\x12\x03V\x06\x13\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03V\x14(\n\ + \x0c\n\x05\x06\0\x02\x06\x03\x12\x03V3O\n\r\n\x05\x06\0\x02\x06\x04\x12\ + \x04W\x04Z\x06\n\x11\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x04W\x04Z\ + \x06\n1\n\x04\x06\0\x02\x07\x12\x04^\x02b\x03\x1a#\x20Gets\x20informatio\ + n\x20about\x20a\x20cluster.\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03^\x06\ + \x10\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03^\x11\"\n\x0c\n\x05\x06\0\x02\ + \x07\x03\x12\x03^-4\n\r\n\x05\x06\0\x02\x07\x04\x12\x04_\x04a\x06\n\x11\ + \n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x04_\x04a\x06\n@\n\x04\x06\0\ + \x02\x08\x12\x04e\x02i\x03\x1a2\x20Lists\x20information\x20about\x20clus\ + ters\x20in\x20an\x20instance.\n\n\x0c\n\x05\x06\0\x02\x08\x01\x12\x03e\ + \x06\x12\n\x0c\n\x05\x06\0\x02\x08\x02\x12\x03e\x13&\n\x0c\n\x05\x06\0\ + \x02\x08\x03\x12\x03e1E\n\r\n\x05\x06\0\x02\x08\x04\x12\x04f\x04h\x06\n\ + \x11\n\t\x06\0\x02\x08\x04\xb0\xca\xbc\"\x12\x04f\x04h\x06\n5\n\x04\x06\ + \0\x02\t\x12\x04l\x02q\x03\x1a'\x20Updates\x20a\x20cluster\x20within\x20\ + an\x20instance.\n\n\x0c\n\x05\x06\0\x02\t\x01\x12\x03l\x06\x13\n\x0c\n\ + \x05\x06\0\x02\t\x02\x12\x03l\x14\x1b\n\x0c\n\x05\x06\0\x02\t\x03\x12\ + \x03l&B\n\r\n\x05\x06\0\x02\t\x04\x12\x04m\x04p\x06\n\x11\n\t\x06\0\x02\ + \t\x04\xb0\xca\xbc\"\x12\x04m\x04p\x06\n3\n\x04\x06\0\x02\n\x12\x04t\x02\ + x\x03\x1a%\x20Deletes\x20a\x20cluster\x20from\x20an\x20instance.\n\n\x0c\ + \n\x05\x06\0\x02\n\x01\x12\x03t\x06\x13\n\x0c\n\x05\x06\0\x02\n\x02\x12\ + \x03t\x14(\n\x0c\n\x05\x06\0\x02\n\x03\x12\x03t3H\n\r\n\x05\x06\0\x02\n\ + \x04\x12\x04u\x04w\x06\n\x11\n\t\x06\0\x02\n\x04\xb0\xca\xbc\"\x12\x04u\ + \x04w\x06\n;\n\x04\x06\0\x02\x0b\x12\x05{\x02\x80\x01\x03\x1a,\x20Create\ + s\x20an\x20app\x20profile\x20within\x20an\x20instance.\n\n\x0c\n\x05\x06\ + \0\x02\x0b\x01\x12\x03{\x06\x16\n\x0c\n\x05\x06\0\x02\x0b\x02\x12\x03{\ + \x17.\n\x0c\n\x05\x06\0\x02\x0b\x03\x12\x03{9C\n\r\n\x05\x06\0\x02\x0b\ + \x04\x12\x04|\x04\x7f\x06\n\x11\n\t\x06\0\x02\x0b\x04\xb0\xca\xbc\"\x12\ + \x04|\x04\x7f\x06\n8\n\x04\x06\0\x02\x0c\x12\x06\x83\x01\x02\x87\x01\x03\ + \x1a(\x20Gets\x20information\x20about\x20an\x20app\x20profile.\n\n\r\n\ + \x05\x06\0\x02\x0c\x01\x12\x04\x83\x01\x06\x13\n\r\n\x05\x06\0\x02\x0c\ + \x02\x12\x04\x83\x01\x14(\n\r\n\x05\x06\0\x02\x0c\x03\x12\x04\x83\x013=\ + \n\x0f\n\x05\x06\0\x02\x0c\x04\x12\x06\x84\x01\x04\x86\x01\x06\n\x13\n\t\ + \x06\0\x02\x0c\x04\xb0\xca\xbc\"\x12\x06\x84\x01\x04\x86\x01\x06\nF\n\ + \x04\x06\0\x02\r\x12\x06\x8a\x01\x02\x8e\x01\x03\x1a6\x20Lists\x20inform\ + ation\x20about\x20app\x20profiles\x20in\x20an\x20instance.\n\n\r\n\x05\ + \x06\0\x02\r\x01\x12\x04\x8a\x01\x06\x15\n\r\n\x05\x06\0\x02\r\x02\x12\ + \x04\x8a\x01\x16,\n\r\n\x05\x06\0\x02\r\x03\x12\x04\x8a\x017N\n\x0f\n\ + \x05\x06\0\x02\r\x04\x12\x06\x8b\x01\x04\x8d\x01\x06\n\x13\n\t\x06\0\x02\ + \r\x04\xb0\xca\xbc\"\x12\x06\x8b\x01\x04\x8d\x01\x06\n<\n\x04\x06\0\x02\ + \x0e\x12\x06\x91\x01\x02\x96\x01\x03\x1a,\x20Updates\x20an\x20app\x20pro\ + file\x20within\x20an\x20instance.\n\n\r\n\x05\x06\0\x02\x0e\x01\x12\x04\ + \x91\x01\x06\x16\n\r\n\x05\x06\0\x02\x0e\x02\x12\x04\x91\x01\x17.\n\r\n\ + \x05\x06\0\x02\x0e\x03\x12\x04\x91\x019U\n\x0f\n\x05\x06\0\x02\x0e\x04\ + \x12\x06\x92\x01\x04\x95\x01\x06\n\x13\n\t\x06\0\x02\x0e\x04\xb0\xca\xbc\ + \"\x12\x06\x92\x01\x04\x95\x01\x06\n:\n\x04\x06\0\x02\x0f\x12\x06\x99\ + \x01\x02\x9d\x01\x03\x1a*\x20Deletes\x20an\x20app\x20profile\x20from\x20\ + an\x20instance.\n\n\r\n\x05\x06\0\x02\x0f\x01\x12\x04\x99\x01\x06\x16\n\ + \r\n\x05\x06\0\x02\x0f\x02\x12\x04\x99\x01\x17.\n\r\n\x05\x06\0\x02\x0f\ + \x03\x12\x04\x99\x019N\n\x0f\n\x05\x06\0\x02\x0f\x04\x12\x06\x9a\x01\x04\ + \x9c\x01\x06\n\x13\n\t\x06\0\x02\x0f\x04\xb0\xca\xbc\"\x12\x06\x9a\x01\ + \x04\x9c\x01\x06\n\x9a\x01\n\x04\x06\0\x02\x10\x12\x06\xa1\x01\x02\xa6\ + \x01\x03\x1a\x89\x01\x20Gets\x20the\x20access\x20control\x20policy\x20fo\ + r\x20an\x20instance\x20resource.\x20Returns\x20an\x20empty\n\x20policy\ + \x20if\x20an\x20instance\x20exists\x20but\x20does\x20not\x20have\x20a\ + \x20policy\x20set.\n\n\r\n\x05\x06\0\x02\x10\x01\x12\x04\xa1\x01\x06\x12\ + \n\r\n\x05\x06\0\x02\x10\x02\x12\x04\xa1\x01\x134\n\r\n\x05\x06\0\x02\ + \x10\x03\x12\x04\xa1\x01?S\n\x0f\n\x05\x06\0\x02\x10\x04\x12\x06\xa2\x01\ + \x04\xa5\x01\x06\n\x13\n\t\x06\0\x02\x10\x04\xb0\xca\xbc\"\x12\x06\xa2\ + \x01\x04\xa5\x01\x06\nh\n\x04\x06\0\x02\x11\x12\x06\xaa\x01\x02\xaf\x01\ + \x03\x1aX\x20Sets\x20the\x20access\x20control\x20policy\x20on\x20an\x20i\ + nstance\x20resource.\x20Replaces\x20any\n\x20existing\x20policy.\n\n\r\n\ + \x05\x06\0\x02\x11\x01\x12\x04\xaa\x01\x06\x12\n\r\n\x05\x06\0\x02\x11\ + \x02\x12\x04\xaa\x01\x134\n\r\n\x05\x06\0\x02\x11\x03\x12\x04\xaa\x01?S\ + \n\x0f\n\x05\x06\0\x02\x11\x04\x12\x06\xab\x01\x04\xae\x01\x06\n\x13\n\t\ + \x06\0\x02\x11\x04\xb0\xca\xbc\"\x12\x06\xab\x01\x04\xae\x01\x06\n]\n\ + \x04\x06\0\x02\x12\x12\x06\xb2\x01\x02\xb7\x01\x03\x1aM\x20Returns\x20pe\ + rmissions\x20that\x20the\x20caller\x20has\x20on\x20the\x20specified\x20i\ + nstance\x20resource.\n\n\r\n\x05\x06\0\x02\x12\x01\x12\x04\xb2\x01\x06\ + \x18\n\r\n\x05\x06\0\x02\x12\x02\x12\x04\xb2\x01\x19@\n\r\n\x05\x06\0\ + \x02\x12\x03\x12\x04\xb2\x01Ks\n\x0f\n\x05\x06\0\x02\x12\x04\x12\x06\xb3\ + \x01\x04\xb6\x01\x06\n\x13\n\t\x06\0\x02\x12\x04\xb0\xca\xbc\"\x12\x06\ + \xb3\x01\x04\xb6\x01\x06\nI\n\x02\x04\0\x12\x06\xbb\x01\0\xcf\x01\x01\ + \x1a;\x20Request\x20message\x20for\x20BigtableInstanceAdmin.CreateInstan\ + ce.\n\n\x0b\n\x03\x04\0\x01\x12\x04\xbb\x01\x08\x1d\n\x81\x01\n\x04\x04\ + \0\x02\0\x12\x04\xbe\x01\x02\x14\x1as\x20The\x20unique\x20name\x20of\x20\ + the\x20project\x20in\x20which\x20to\x20create\x20the\x20new\x20instance.\ + \n\x20Values\x20are\x20of\x20the\x20form\x20`projects/`.\n\n\ + \x0f\n\x05\x04\0\x02\0\x04\x12\x06\xbe\x01\x02\xbb\x01\x1f\n\r\n\x05\x04\ + \0\x02\0\x05\x12\x04\xbe\x01\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\ + \xbe\x01\t\x0f\n\r\n\x05\x04\0\x02\0\x03\x12\x04\xbe\x01\x12\x13\n\xaa\ + \x01\n\x04\x04\0\x02\x01\x12\x04\xc3\x01\x02\x19\x1a\x9b\x01\x20The\x20I\ + D\x20to\x20be\x20used\x20when\x20referring\x20to\x20the\x20new\x20instan\ + ce\x20within\x20its\x20project,\n\x20e.g.,\x20just\x20`myinstance`\x20ra\ + ther\x20than\n\x20`projects/myproject/instances/myinstance`.\n\n\x0f\n\ + \x05\x04\0\x02\x01\x04\x12\x06\xc3\x01\x02\xbe\x01\x14\n\r\n\x05\x04\0\ + \x02\x01\x05\x12\x04\xc3\x01\x02\x08\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\ + \xc3\x01\t\x14\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\xc3\x01\x17\x18\nW\n\ + \x04\x04\0\x02\x02\x12\x04\xc7\x01\x02\x18\x1aI\x20The\x20instance\x20to\ + \x20create.\n\x20Fields\x20marked\x20`OutputOnly`\x20must\x20be\x20left\ + \x20blank.\n\n\x0f\n\x05\x04\0\x02\x02\x04\x12\x06\xc7\x01\x02\xc3\x01\ + \x19\n\r\n\x05\x04\0\x02\x02\x06\x12\x04\xc7\x01\x02\n\n\r\n\x05\x04\0\ + \x02\x02\x01\x12\x04\xc7\x01\x0b\x13\n\r\n\x05\x04\0\x02\x02\x03\x12\x04\ + \xc7\x01\x16\x17\n\xa4\x02\n\x04\x04\0\x02\x03\x12\x04\xce\x01\x02$\x1a\ + \x95\x02\x20The\x20clusters\x20to\x20be\x20created\x20within\x20the\x20i\ + nstance,\x20mapped\x20by\x20desired\n\x20cluster\x20ID,\x20e.g.,\x20just\ + \x20`mycluster`\x20rather\x20than\n\x20`projects/myproject/instances/myi\ + nstance/clusters/mycluster`.\n\x20Fields\x20marked\x20`OutputOnly`\x20mu\ + st\x20be\x20left\x20blank.\n\x20Currently,\x20at\x20most\x20two\x20clust\ + ers\x20can\x20be\x20specified.\n\n\x0f\n\x05\x04\0\x02\x03\x04\x12\x06\ + \xce\x01\x02\xc7\x01\x18\n\r\n\x05\x04\0\x02\x03\x06\x12\x04\xce\x01\x02\ + \x16\n\r\n\x05\x04\0\x02\x03\x01\x12\x04\xce\x01\x17\x1f\n\r\n\x05\x04\0\ + \x02\x03\x03\x12\x04\xce\x01\"#\nF\n\x02\x04\x01\x12\x06\xd2\x01\0\xd6\ + \x01\x01\x1a8\x20Request\x20message\x20for\x20BigtableInstanceAdmin.GetI\ + nstance.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xd2\x01\x08\x1a\n}\n\x04\x04\ + \x01\x02\0\x12\x04\xd5\x01\x02\x12\x1ao\x20The\x20unique\x20name\x20of\ + \x20the\x20requested\x20instance.\x20Values\x20are\x20of\x20the\x20form\ + \n\x20`projects//instances/`.\n\n\x0f\n\x05\x04\x01\ + \x02\0\x04\x12\x06\xd5\x01\x02\xd2\x01\x1c\n\r\n\x05\x04\x01\x02\0\x05\ + \x12\x04\xd5\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xd5\x01\t\r\ + \n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xd5\x01\x10\x11\nH\n\x02\x04\x02\ + \x12\x06\xd9\x01\0\xe0\x01\x01\x1a:\x20Request\x20message\x20for\x20Bigt\ + ableInstanceAdmin.ListInstances.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xd9\ + \x01\x08\x1c\n\x88\x01\n\x04\x04\x02\x02\0\x12\x04\xdc\x01\x02\x14\x1az\ + \x20The\x20unique\x20name\x20of\x20the\x20project\x20for\x20which\x20a\ + \x20list\x20of\x20instances\x20is\x20requested.\n\x20Values\x20are\x20of\ + \x20the\x20form\x20`projects/`.\n\n\x0f\n\x05\x04\x02\x02\0\x04\ + \x12\x06\xdc\x01\x02\xd9\x01\x1e\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xdc\ + \x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xdc\x01\t\x0f\n\r\n\x05\ + \x04\x02\x02\0\x03\x12\x04\xdc\x01\x12\x13\n=\n\x04\x04\x02\x02\x01\x12\ + \x04\xdf\x01\x02\x18\x1a/\x20DEPRECATED:\x20This\x20field\x20is\x20unuse\ + d\x20and\x20ignored.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\x06\xdf\x01\ + \x02\xdc\x01\x14\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xdf\x01\x02\x08\n\ + \r\n\x05\x04\x02\x02\x01\x01\x12\x04\xdf\x01\t\x13\n\r\n\x05\x04\x02\x02\ + \x01\x03\x12\x04\xdf\x01\x16\x17\nI\n\x02\x04\x03\x12\x06\xe3\x01\0\xf1\ + \x01\x01\x1a;\x20Response\x20message\x20for\x20BigtableInstanceAdmin.Lis\ + tInstances.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xe3\x01\x08\x1d\n0\n\x04\ + \x04\x03\x02\0\x12\x04\xe5\x01\x02\"\x1a\"\x20The\x20list\x20of\x20reque\ + sted\x20instances.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\xe5\x01\x02\n\n\ + \r\n\x05\x04\x03\x02\0\x06\x12\x04\xe5\x01\x0b\x13\n\r\n\x05\x04\x03\x02\ + \0\x01\x12\x04\xe5\x01\x14\x1d\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xe5\ + \x01\x20!\n\x95\x03\n\x04\x04\x03\x02\x01\x12\x04\xed\x01\x02'\x1a\x86\ + \x03\x20Locations\x20from\x20which\x20Instance\x20information\x20could\ + \x20not\x20be\x20retrieved,\n\x20due\x20to\x20an\x20outage\x20or\x20some\ + \x20other\x20transient\x20condition.\n\x20Instances\x20whose\x20Clusters\ + \x20are\x20all\x20in\x20one\x20of\x20the\x20failed\x20locations\n\x20may\ + \x20be\x20missing\x20from\x20`instances`,\x20and\x20Instances\x20with\ + \x20at\x20least\x20one\n\x20Cluster\x20in\x20a\x20failed\x20location\x20\ + may\x20only\x20have\x20partial\x20information\x20returned.\n\x20Values\ + \x20are\x20of\x20the\x20form\x20`projects//locations/`\ + \n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04\xed\x01\x02\n\n\r\n\x05\x04\x03\ + \x02\x01\x05\x12\x04\xed\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x01\x01\x12\ + \x04\xed\x01\x12\"\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xed\x01%&\n=\n\ + \x04\x04\x03\x02\x02\x12\x04\xf0\x01\x02\x1d\x1a/\x20DEPRECATED:\x20This\ + \x20field\x20is\x20unused\x20and\x20ignored.\n\n\x0f\n\x05\x04\x03\x02\ + \x02\x04\x12\x06\xf0\x01\x02\xed\x01'\n\r\n\x05\x04\x03\x02\x02\x05\x12\ + \x04\xf0\x01\x02\x08\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xf0\x01\t\x18\ + \n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xf0\x01\x1b\x1c\nP\n\x02\x04\x04\ + \x12\x06\xf4\x01\0\xfb\x01\x01\x1aB\x20Request\x20message\x20for\x20Bigt\ + ableInstanceAdmin.PartialUpdateInstance.\n\n\x0b\n\x03\x04\x04\x01\x12\ + \x04\xf4\x01\x08$\nN\n\x04\x04\x04\x02\0\x12\x04\xf6\x01\x02\x18\x1a@\ + \x20The\x20Instance\x20which\x20will\x20(partially)\x20replace\x20the\ + \x20current\x20value.\n\n\x0f\n\x05\x04\x04\x02\0\x04\x12\x06\xf6\x01\ + \x02\xf4\x01&\n\r\n\x05\x04\x04\x02\0\x06\x12\x04\xf6\x01\x02\n\n\r\n\ + \x05\x04\x04\x02\0\x01\x12\x04\xf6\x01\x0b\x13\n\r\n\x05\x04\x04\x02\0\ + \x03\x12\x04\xf6\x01\x16\x17\n`\n\x04\x04\x04\x02\x01\x12\x04\xfa\x01\ + \x02,\x1aR\x20The\x20subset\x20of\x20Instance\x20fields\x20which\x20shou\ + ld\x20be\x20replaced.\n\x20Must\x20be\x20explicitly\x20set.\n\n\x0f\n\ + \x05\x04\x04\x02\x01\x04\x12\x06\xfa\x01\x02\xf6\x01\x18\n\r\n\x05\x04\ + \x04\x02\x01\x06\x12\x04\xfa\x01\x02\x1b\n\r\n\x05\x04\x04\x02\x01\x01\ + \x12\x04\xfa\x01\x1c'\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xfa\x01*+\nI\ + \n\x02\x04\x05\x12\x06\xfe\x01\0\x82\x02\x01\x1a;\x20Request\x20message\ + \x20for\x20BigtableInstanceAdmin.DeleteInstance.\n\n\x0b\n\x03\x04\x05\ + \x01\x12\x04\xfe\x01\x08\x1d\n\x81\x01\n\x04\x04\x05\x02\0\x12\x04\x81\ + \x02\x02\x12\x1as\x20The\x20unique\x20name\x20of\x20the\x20instance\x20t\ + o\x20be\x20deleted.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects\ + //instances/`.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\ + \x06\x81\x02\x02\xfe\x01\x1f\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x81\x02\ + \x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x81\x02\t\r\n\r\n\x05\x04\ + \x05\x02\0\x03\x12\x04\x81\x02\x10\x11\nH\n\x02\x04\x06\x12\x06\x85\x02\ + \0\x93\x02\x01\x1a:\x20Request\x20message\x20for\x20BigtableInstanceAdmi\ + n.CreateCluster.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\x85\x02\x08\x1c\n\x98\ + \x01\n\x04\x04\x06\x02\0\x12\x04\x89\x02\x02\x14\x1a\x89\x01\x20The\x20u\ + nique\x20name\x20of\x20the\x20instance\x20in\x20which\x20to\x20create\ + \x20the\x20new\x20cluster.\n\x20Values\x20are\x20of\x20the\x20form\n\x20\ + `projects//instances/`.\n\n\x0f\n\x05\x04\x06\x02\0\ + \x04\x12\x06\x89\x02\x02\x85\x02\x1e\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\ + \x89\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\x89\x02\t\x0f\n\r\n\ + \x05\x04\x06\x02\0\x03\x12\x04\x89\x02\x12\x13\n\xbc\x01\n\x04\x04\x06\ + \x02\x01\x12\x04\x8e\x02\x02\x18\x1a\xad\x01\x20The\x20ID\x20to\x20be\ + \x20used\x20when\x20referring\x20to\x20the\x20new\x20cluster\x20within\ + \x20its\x20instance,\n\x20e.g.,\x20just\x20`mycluster`\x20rather\x20than\ + \n\x20`projects/myproject/instances/myinstance/clusters/mycluster`.\n\n\ + \x0f\n\x05\x04\x06\x02\x01\x04\x12\x06\x8e\x02\x02\x89\x02\x14\n\r\n\x05\ + \x04\x06\x02\x01\x05\x12\x04\x8e\x02\x02\x08\n\r\n\x05\x04\x06\x02\x01\ + \x01\x12\x04\x8e\x02\t\x13\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\x8e\x02\ + \x16\x17\nZ\n\x04\x04\x06\x02\x02\x12\x04\x92\x02\x02\x16\x1aL\x20The\ + \x20cluster\x20to\x20be\x20created.\n\x20Fields\x20marked\x20`OutputOnly\ + `\x20must\x20be\x20left\x20blank.\n\n\x0f\n\x05\x04\x06\x02\x02\x04\x12\ + \x06\x92\x02\x02\x8e\x02\x18\n\r\n\x05\x04\x06\x02\x02\x06\x12\x04\x92\ + \x02\x02\t\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\x92\x02\n\x11\n\r\n\x05\ + \x04\x06\x02\x02\x03\x12\x04\x92\x02\x14\x15\nE\n\x02\x04\x07\x12\x06\ + \x96\x02\0\x9a\x02\x01\x1a7\x20Request\x20message\x20for\x20BigtableInst\ + anceAdmin.GetCluster.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\x96\x02\x08\x19\ + \n\x90\x01\n\x04\x04\x07\x02\0\x12\x04\x99\x02\x02\x12\x1a\x81\x01\x20Th\ + e\x20unique\x20name\x20of\x20the\x20requested\x20cluster.\x20Values\x20a\ + re\x20of\x20the\x20form\n\x20`projects//instances//cl\ + usters/`.\n\n\x0f\n\x05\x04\x07\x02\0\x04\x12\x06\x99\x02\x02\ + \x96\x02\x1b\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\x99\x02\x02\x08\n\r\n\ + \x05\x04\x07\x02\0\x01\x12\x04\x99\x02\t\r\n\r\n\x05\x04\x07\x02\0\x03\ + \x12\x04\x99\x02\x10\x11\nG\n\x02\x04\x08\x12\x06\x9d\x02\0\xa6\x02\x01\ + \x1a9\x20Request\x20message\x20for\x20BigtableInstanceAdmin.ListClusters\ + .\n\n\x0b\n\x03\x04\x08\x01\x12\x04\x9d\x02\x08\x1b\n\x90\x02\n\x04\x04\ + \x08\x02\0\x12\x04\xa2\x02\x02\x14\x1a\x81\x02\x20The\x20unique\x20name\ + \x20of\x20the\x20instance\x20for\x20which\x20a\x20list\x20of\x20clusters\ + \x20is\x20requested.\n\x20Values\x20are\x20of\x20the\x20form\x20`project\ + s//instances/`.\n\x20Use\x20`\x20=\x20'-'`\ + \x20to\x20list\x20Clusters\x20for\x20all\x20Instances\x20in\x20a\x20proj\ + ect,\n\x20e.g.,\x20`projects/myproject/instances/-`.\n\n\x0f\n\x05\x04\ + \x08\x02\0\x04\x12\x06\xa2\x02\x02\x9d\x02\x1d\n\r\n\x05\x04\x08\x02\0\ + \x05\x12\x04\xa2\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xa2\x02\ + \t\x0f\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xa2\x02\x12\x13\n=\n\x04\x04\ + \x08\x02\x01\x12\x04\xa5\x02\x02\x18\x1a/\x20DEPRECATED:\x20This\x20fiel\ + d\x20is\x20unused\x20and\x20ignored.\n\n\x0f\n\x05\x04\x08\x02\x01\x04\ + \x12\x06\xa5\x02\x02\xa2\x02\x14\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\ + \xa5\x02\x02\x08\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\xa5\x02\t\x13\n\r\ + \n\x05\x04\x08\x02\x01\x03\x12\x04\xa5\x02\x16\x17\nH\n\x02\x04\t\x12\ + \x06\xa9\x02\0\xb6\x02\x01\x1a:\x20Response\x20message\x20for\x20Bigtabl\ + eInstanceAdmin.ListClusters.\n\n\x0b\n\x03\x04\t\x01\x12\x04\xa9\x02\x08\ + \x1c\n/\n\x04\x04\t\x02\0\x12\x04\xab\x02\x02\x20\x1a!\x20The\x20list\ + \x20of\x20requested\x20clusters.\n\n\r\n\x05\x04\t\x02\0\x04\x12\x04\xab\ + \x02\x02\n\n\r\n\x05\x04\t\x02\0\x06\x12\x04\xab\x02\x0b\x12\n\r\n\x05\ + \x04\t\x02\0\x01\x12\x04\xab\x02\x13\x1b\n\r\n\x05\x04\t\x02\0\x03\x12\ + \x04\xab\x02\x1e\x1f\n\xb6\x02\n\x04\x04\t\x02\x01\x12\x04\xb2\x02\x02'\ + \x1a\xa7\x02\x20Locations\x20from\x20which\x20Cluster\x20information\x20\ + could\x20not\x20be\x20retrieved,\n\x20due\x20to\x20an\x20outage\x20or\ + \x20some\x20other\x20transient\x20condition.\n\x20Clusters\x20from\x20th\ + ese\x20locations\x20may\x20be\x20missing\x20from\x20`clusters`,\n\x20or\ + \x20may\x20only\x20have\x20partial\x20information\x20returned.\n\x20Valu\ + es\x20are\x20of\x20the\x20form\x20`projects//locations/`\n\n\r\n\x05\x04\t\x02\x01\x04\x12\x04\xb2\x02\x02\n\n\r\n\x05\x04\t\ + \x02\x01\x05\x12\x04\xb2\x02\x0b\x11\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\ + \xb2\x02\x12\"\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xb2\x02%&\n=\n\x04\ + \x04\t\x02\x02\x12\x04\xb5\x02\x02\x1d\x1a/\x20DEPRECATED:\x20This\x20fi\ + eld\x20is\x20unused\x20and\x20ignored.\n\n\x0f\n\x05\x04\t\x02\x02\x04\ + \x12\x06\xb5\x02\x02\xb2\x02'\n\r\n\x05\x04\t\x02\x02\x05\x12\x04\xb5\ + \x02\x02\x08\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xb5\x02\t\x18\n\r\n\x05\ + \x04\t\x02\x02\x03\x12\x04\xb5\x02\x1b\x1c\nH\n\x02\x04\n\x12\x06\xb9\ + \x02\0\xbd\x02\x01\x1a:\x20Request\x20message\x20for\x20BigtableInstance\ + Admin.DeleteCluster.\n\n\x0b\n\x03\x04\n\x01\x12\x04\xb9\x02\x08\x1c\n\ + \x94\x01\n\x04\x04\n\x02\0\x12\x04\xbc\x02\x02\x12\x1a\x85\x01\x20The\ + \x20unique\x20name\x20of\x20the\x20cluster\x20to\x20be\x20deleted.\x20Va\ + lues\x20are\x20of\x20the\x20form\n\x20`projects//instances//clusters/`.\n\n\x0f\n\x05\x04\n\x02\0\x04\x12\x06\xbc\ + \x02\x02\xb9\x02\x1e\n\r\n\x05\x04\n\x02\0\x05\x12\x04\xbc\x02\x02\x08\n\ + \r\n\x05\x04\n\x02\0\x01\x12\x04\xbc\x02\t\r\n\r\n\x05\x04\n\x02\0\x03\ + \x12\x04\xbc\x02\x10\x11\nJ\n\x02\x04\x0b\x12\x06\xc0\x02\0\xc9\x02\x01\ + \x1a<\x20The\x20metadata\x20for\x20the\x20Operation\x20returned\x20by\ + \x20CreateInstance.\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\xc0\x02\x08\x1e\nZ\ + \n\x04\x04\x0b\x02\0\x12\x04\xc2\x02\x02-\x1aL\x20The\x20request\x20that\ + \x20prompted\x20the\x20initiation\x20of\x20this\x20CreateInstance\x20ope\ + ration.\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\xc2\x02\x02\xc0\x02\x20\ + \n\r\n\x05\x04\x0b\x02\0\x06\x12\x04\xc2\x02\x02\x17\n\r\n\x05\x04\x0b\ + \x02\0\x01\x12\x04\xc2\x02\x18(\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xc2\ + \x02+,\nD\n\x04\x04\x0b\x02\x01\x12\x04\xc5\x02\x02-\x1a6\x20The\x20time\ + \x20at\x20which\x20the\x20original\x20request\x20was\x20received.\n\n\ + \x0f\n\x05\x04\x0b\x02\x01\x04\x12\x06\xc5\x02\x02\xc2\x02-\n\r\n\x05\ + \x04\x0b\x02\x01\x06\x12\x04\xc5\x02\x02\x1b\n\r\n\x05\x04\x0b\x02\x01\ + \x01\x12\x04\xc5\x02\x1c(\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\xc5\x02+\ + ,\nU\n\x04\x04\x0b\x02\x02\x12\x04\xc8\x02\x02,\x1aG\x20The\x20time\x20a\ + t\x20which\x20the\x20operation\x20failed\x20or\x20was\x20completed\x20su\ + ccessfully.\n\n\x0f\n\x05\x04\x0b\x02\x02\x04\x12\x06\xc8\x02\x02\xc5\ + \x02-\n\r\n\x05\x04\x0b\x02\x02\x06\x12\x04\xc8\x02\x02\x1b\n\r\n\x05\ + \x04\x0b\x02\x02\x01\x12\x04\xc8\x02\x1c'\n\r\n\x05\x04\x0b\x02\x02\x03\ + \x12\x04\xc8\x02*+\nJ\n\x02\x04\x0c\x12\x06\xcc\x02\0\xd5\x02\x01\x1a<\ + \x20The\x20metadata\x20for\x20the\x20Operation\x20returned\x20by\x20Upda\ + teInstance.\n\n\x0b\n\x03\x04\x0c\x01\x12\x04\xcc\x02\x08\x1e\nZ\n\x04\ + \x04\x0c\x02\0\x12\x04\xce\x02\x024\x1aL\x20The\x20request\x20that\x20pr\ + ompted\x20the\x20initiation\x20of\x20this\x20UpdateInstance\x20operation\ + .\n\n\x0f\n\x05\x04\x0c\x02\0\x04\x12\x06\xce\x02\x02\xcc\x02\x20\n\r\n\ + \x05\x04\x0c\x02\0\x06\x12\x04\xce\x02\x02\x1e\n\r\n\x05\x04\x0c\x02\0\ + \x01\x12\x04\xce\x02\x1f/\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\xce\x0223\ + \nD\n\x04\x04\x0c\x02\x01\x12\x04\xd1\x02\x02-\x1a6\x20The\x20time\x20at\ + \x20which\x20the\x20original\x20request\x20was\x20received.\n\n\x0f\n\ + \x05\x04\x0c\x02\x01\x04\x12\x06\xd1\x02\x02\xce\x024\n\r\n\x05\x04\x0c\ + \x02\x01\x06\x12\x04\xd1\x02\x02\x1b\n\r\n\x05\x04\x0c\x02\x01\x01\x12\ + \x04\xd1\x02\x1c(\n\r\n\x05\x04\x0c\x02\x01\x03\x12\x04\xd1\x02+,\nU\n\ + \x04\x04\x0c\x02\x02\x12\x04\xd4\x02\x02,\x1aG\x20The\x20time\x20at\x20w\ + hich\x20the\x20operation\x20failed\x20or\x20was\x20completed\x20successf\ + ully.\n\n\x0f\n\x05\x04\x0c\x02\x02\x04\x12\x06\xd4\x02\x02\xd1\x02-\n\r\ + \n\x05\x04\x0c\x02\x02\x06\x12\x04\xd4\x02\x02\x1b\n\r\n\x05\x04\x0c\x02\ + \x02\x01\x12\x04\xd4\x02\x1c'\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xd4\ + \x02*+\nI\n\x02\x04\r\x12\x06\xd8\x02\0\xe1\x02\x01\x1a;\x20The\x20metad\ + ata\x20for\x20the\x20Operation\x20returned\x20by\x20CreateCluster.\n\n\ + \x0b\n\x03\x04\r\x01\x12\x04\xd8\x02\x08\x1d\nY\n\x04\x04\r\x02\0\x12\ + \x04\xda\x02\x02,\x1aK\x20The\x20request\x20that\x20prompted\x20the\x20i\ + nitiation\x20of\x20this\x20CreateCluster\x20operation.\n\n\x0f\n\x05\x04\ + \r\x02\0\x04\x12\x06\xda\x02\x02\xd8\x02\x1f\n\r\n\x05\x04\r\x02\0\x06\ + \x12\x04\xda\x02\x02\x16\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xda\x02\x17'\ + \n\r\n\x05\x04\r\x02\0\x03\x12\x04\xda\x02*+\nD\n\x04\x04\r\x02\x01\x12\ + \x04\xdd\x02\x02-\x1a6\x20The\x20time\x20at\x20which\x20the\x20original\ + \x20request\x20was\x20received.\n\n\x0f\n\x05\x04\r\x02\x01\x04\x12\x06\ + \xdd\x02\x02\xda\x02,\n\r\n\x05\x04\r\x02\x01\x06\x12\x04\xdd\x02\x02\ + \x1b\n\r\n\x05\x04\r\x02\x01\x01\x12\x04\xdd\x02\x1c(\n\r\n\x05\x04\r\ + \x02\x01\x03\x12\x04\xdd\x02+,\nU\n\x04\x04\r\x02\x02\x12\x04\xe0\x02\ + \x02,\x1aG\x20The\x20time\x20at\x20which\x20the\x20operation\x20failed\ + \x20or\x20was\x20completed\x20successfully.\n\n\x0f\n\x05\x04\r\x02\x02\ + \x04\x12\x06\xe0\x02\x02\xdd\x02-\n\r\n\x05\x04\r\x02\x02\x06\x12\x04\ + \xe0\x02\x02\x1b\n\r\n\x05\x04\r\x02\x02\x01\x12\x04\xe0\x02\x1c'\n\r\n\ + \x05\x04\r\x02\x02\x03\x12\x04\xe0\x02*+\nI\n\x02\x04\x0e\x12\x06\xe4\ + \x02\0\xed\x02\x01\x1a;\x20The\x20metadata\x20for\x20the\x20Operation\ + \x20returned\x20by\x20UpdateCluster.\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\ + \xe4\x02\x08\x1d\nY\n\x04\x04\x0e\x02\0\x12\x04\xe6\x02\x02\x1f\x1aK\x20\ + The\x20request\x20that\x20prompted\x20the\x20initiation\x20of\x20this\ + \x20UpdateCluster\x20operation.\n\n\x0f\n\x05\x04\x0e\x02\0\x04\x12\x06\ + \xe6\x02\x02\xe4\x02\x1f\n\r\n\x05\x04\x0e\x02\0\x06\x12\x04\xe6\x02\x02\ + \t\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xe6\x02\n\x1a\n\r\n\x05\x04\x0e\ + \x02\0\x03\x12\x04\xe6\x02\x1d\x1e\nD\n\x04\x04\x0e\x02\x01\x12\x04\xe9\ + \x02\x02-\x1a6\x20The\x20time\x20at\x20which\x20the\x20original\x20reque\ + st\x20was\x20received.\n\n\x0f\n\x05\x04\x0e\x02\x01\x04\x12\x06\xe9\x02\ + \x02\xe6\x02\x1f\n\r\n\x05\x04\x0e\x02\x01\x06\x12\x04\xe9\x02\x02\x1b\n\ + \r\n\x05\x04\x0e\x02\x01\x01\x12\x04\xe9\x02\x1c(\n\r\n\x05\x04\x0e\x02\ + \x01\x03\x12\x04\xe9\x02+,\nU\n\x04\x04\x0e\x02\x02\x12\x04\xec\x02\x02,\ + \x1aG\x20The\x20time\x20at\x20which\x20the\x20operation\x20failed\x20or\ + \x20was\x20completed\x20successfully.\n\n\x0f\n\x05\x04\x0e\x02\x02\x04\ + \x12\x06\xec\x02\x02\xe9\x02-\n\r\n\x05\x04\x0e\x02\x02\x06\x12\x04\xec\ + \x02\x02\x1b\n\r\n\x05\x04\x0e\x02\x02\x01\x12\x04\xec\x02\x1c'\n\r\n\ + \x05\x04\x0e\x02\x02\x03\x12\x04\xec\x02*+\nK\n\x02\x04\x0f\x12\x06\xf0\ + \x02\0\x81\x03\x01\x1a=\x20Request\x20message\x20for\x20BigtableInstance\ + Admin.CreateAppProfile.\n\n\x0b\n\x03\x04\x0f\x01\x12\x04\xf0\x02\x08\ + \x1f\n\x9c\x01\n\x04\x04\x0f\x02\0\x12\x04\xf4\x02\x02\x14\x1a\x8d\x01\ + \x20The\x20unique\x20name\x20of\x20the\x20instance\x20in\x20which\x20to\ + \x20create\x20the\x20new\x20app\x20profile.\n\x20Values\x20are\x20of\x20\ + the\x20form\n\x20`projects//instances/`.\n\n\x0f\n\ + \x05\x04\x0f\x02\0\x04\x12\x06\xf4\x02\x02\xf0\x02!\n\r\n\x05\x04\x0f\ + \x02\0\x05\x12\x04\xf4\x02\x02\x08\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\ + \xf4\x02\t\x0f\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xf4\x02\x12\x13\n\xc3\ + \x01\n\x04\x04\x0f\x02\x01\x12\x04\xf9\x02\x02\x1c\x1a\xb4\x01\x20The\ + \x20ID\x20to\x20be\x20used\x20when\x20referring\x20to\x20the\x20new\x20a\ + pp\x20profile\x20within\x20its\n\x20instance,\x20e.g.,\x20just\x20`mypro\ + file`\x20rather\x20than\n\x20`projects/myproject/instances/myinstance/ap\ + pProfiles/myprofile`.\n\n\x0f\n\x05\x04\x0f\x02\x01\x04\x12\x06\xf9\x02\ + \x02\xf4\x02\x14\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\xf9\x02\x02\x08\n\ + \r\n\x05\x04\x0f\x02\x01\x01\x12\x04\xf9\x02\t\x17\n\r\n\x05\x04\x0f\x02\ + \x01\x03\x12\x04\xf9\x02\x1a\x1b\n[\n\x04\x04\x0f\x02\x02\x12\x04\xfd\ + \x02\x02\x1d\x1aM\x20The\x20app\x20profile\x20to\x20be\x20created.\n\x20\ + Fields\x20marked\x20`OutputOnly`\x20will\x20be\x20ignored.\n\n\x0f\n\x05\ + \x04\x0f\x02\x02\x04\x12\x06\xfd\x02\x02\xf9\x02\x1c\n\r\n\x05\x04\x0f\ + \x02\x02\x06\x12\x04\xfd\x02\x02\x0c\n\r\n\x05\x04\x0f\x02\x02\x01\x12\ + \x04\xfd\x02\r\x18\n\r\n\x05\x04\x0f\x02\x02\x03\x12\x04\xfd\x02\x1b\x1c\ + \nL\n\x04\x04\x0f\x02\x03\x12\x04\x80\x03\x02\x1b\x1a>\x20If\x20true,\ + \x20ignore\x20safety\x20checks\x20when\x20creating\x20the\x20app\x20prof\ + ile.\n\n\x0f\n\x05\x04\x0f\x02\x03\x04\x12\x06\x80\x03\x02\xfd\x02\x1d\n\ + \r\n\x05\x04\x0f\x02\x03\x05\x12\x04\x80\x03\x02\x06\n\r\n\x05\x04\x0f\ + \x02\x03\x01\x12\x04\x80\x03\x07\x16\n\r\n\x05\x04\x0f\x02\x03\x03\x12\ + \x04\x80\x03\x19\x1a\nH\n\x02\x04\x10\x12\x06\x84\x03\0\x88\x03\x01\x1a:\ + \x20Request\x20message\x20for\x20BigtableInstanceAdmin.GetAppProfile.\n\ + \n\x0b\n\x03\x04\x10\x01\x12\x04\x84\x03\x08\x1c\n\x9b\x01\n\x04\x04\x10\ + \x02\0\x12\x04\x87\x03\x02\x12\x1a\x8c\x01\x20The\x20unique\x20name\x20o\ + f\x20the\x20requested\x20app\x20profile.\x20Values\x20are\x20of\x20the\ + \x20form\n\x20`projects//instances//appProfiles/`.\n\n\x0f\n\x05\x04\x10\x02\0\x04\x12\x06\x87\x03\x02\x84\x03\ + \x1e\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\x87\x03\x02\x08\n\r\n\x05\x04\ + \x10\x02\0\x01\x12\x04\x87\x03\t\r\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\ + \x87\x03\x10\x11\nJ\n\x02\x04\x11\x12\x06\x8b\x03\0\x99\x03\x01\x1a<\x20\ + Request\x20message\x20for\x20BigtableInstanceAdmin.ListAppProfiles.\n\n\ + \x0b\n\x03\x04\x11\x01\x12\x04\x8b\x03\x08\x1e\n\x98\x02\n\x04\x04\x11\ + \x02\0\x12\x04\x91\x03\x02\x14\x1a\x89\x02\x20The\x20unique\x20name\x20o\ + f\x20the\x20instance\x20for\x20which\x20a\x20list\x20of\x20app\x20profil\ + es\x20is\n\x20requested.\x20Values\x20are\x20of\x20the\x20form\n\x20`pro\ + jects//instances/`.\n\x20Use\x20`\x20=\x20'\ + -'`\x20to\x20list\x20AppProfiles\x20for\x20all\x20Instances\x20in\x20a\ + \x20project,\n\x20e.g.,\x20`projects/myproject/instances/-`.\n\n\x0f\n\ + \x05\x04\x11\x02\0\x04\x12\x06\x91\x03\x02\x8b\x03\x20\n\r\n\x05\x04\x11\ + \x02\0\x05\x12\x04\x91\x03\x02\x08\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\ + \x91\x03\t\x0f\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\x91\x03\x12\x13\nY\n\ + \x04\x04\x11\x02\x01\x12\x04\x95\x03\x02\x16\x1aK\x20Maximum\x20number\ + \x20of\x20results\x20per\x20page.\n\x20CURRENTLY\x20UNIMPLEMENTED\x20AND\ + \x20IGNORED.\n\n\x0f\n\x05\x04\x11\x02\x01\x04\x12\x06\x95\x03\x02\x91\ + \x03\x14\n\r\n\x05\x04\x11\x02\x01\x05\x12\x04\x95\x03\x02\x07\n\r\n\x05\ + \x04\x11\x02\x01\x01\x12\x04\x95\x03\x08\x11\n\r\n\x05\x04\x11\x02\x01\ + \x03\x12\x04\x95\x03\x14\x15\nK\n\x04\x04\x11\x02\x02\x12\x04\x98\x03\ + \x02\x18\x1a=\x20The\x20value\x20of\x20`next_page_token`\x20returned\x20\ + by\x20a\x20previous\x20call.\n\n\x0f\n\x05\x04\x11\x02\x02\x04\x12\x06\ + \x98\x03\x02\x95\x03\x16\n\r\n\x05\x04\x11\x02\x02\x05\x12\x04\x98\x03\ + \x02\x08\n\r\n\x05\x04\x11\x02\x02\x01\x12\x04\x98\x03\t\x13\n\r\n\x05\ + \x04\x11\x02\x02\x03\x12\x04\x98\x03\x16\x17\nK\n\x02\x04\x12\x12\x06\ + \x9c\x03\0\xaa\x03\x01\x1a=\x20Response\x20message\x20for\x20BigtableIns\ + tanceAdmin.ListAppProfiles.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\x9c\x03\ + \x08\x1f\n3\n\x04\x04\x12\x02\0\x12\x04\x9e\x03\x02'\x1a%\x20The\x20list\ + \x20of\x20requested\x20app\x20profiles.\n\n\r\n\x05\x04\x12\x02\0\x04\ + \x12\x04\x9e\x03\x02\n\n\r\n\x05\x04\x12\x02\0\x06\x12\x04\x9e\x03\x0b\ + \x15\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\x9e\x03\x16\"\n\r\n\x05\x04\x12\ + \x02\0\x03\x12\x04\x9e\x03%&\n\xaa\x01\n\x04\x04\x12\x02\x01\x12\x04\xa3\ + \x03\x02\x1d\x1a\x9b\x01\x20Set\x20if\x20not\x20all\x20app\x20profiles\ + \x20could\x20be\x20returned\x20in\x20a\x20single\x20response.\n\x20Pass\ + \x20this\x20value\x20to\x20`page_token`\x20in\x20another\x20request\x20t\ + o\x20get\x20the\x20next\n\x20page\x20of\x20results.\n\n\x0f\n\x05\x04\ + \x12\x02\x01\x04\x12\x06\xa3\x03\x02\x9e\x03'\n\r\n\x05\x04\x12\x02\x01\ + \x05\x12\x04\xa3\x03\x02\x08\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xa3\ + \x03\t\x18\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\xa3\x03\x1b\x1c\n\x90\ + \x02\n\x04\x04\x12\x02\x02\x12\x04\xa9\x03\x02'\x1a\x81\x02\x20Locations\ + \x20from\x20which\x20AppProfile\x20information\x20could\x20not\x20be\x20\ + retrieved,\n\x20due\x20to\x20an\x20outage\x20or\x20some\x20other\x20tran\ + sient\x20condition.\n\x20AppProfiles\x20from\x20these\x20locations\x20ma\ + y\x20be\x20missing\x20from\x20`app_profiles`.\n\x20Values\x20are\x20of\ + \x20the\x20form\x20`projects//locations/`\n\n\r\n\x05\ + \x04\x12\x02\x02\x04\x12\x04\xa9\x03\x02\n\n\r\n\x05\x04\x12\x02\x02\x05\ + \x12\x04\xa9\x03\x0b\x11\n\r\n\x05\x04\x12\x02\x02\x01\x12\x04\xa9\x03\ + \x12\"\n\r\n\x05\x04\x12\x02\x02\x03\x12\x04\xa9\x03%&\nK\n\x02\x04\x13\ + \x12\x06\xad\x03\0\xb7\x03\x01\x1a=\x20Request\x20message\x20for\x20Bigt\ + ableInstanceAdmin.UpdateAppProfile.\n\n\x0b\n\x03\x04\x13\x01\x12\x04\ + \xad\x03\x08\x1f\nQ\n\x04\x04\x13\x02\0\x12\x04\xaf\x03\x02\x1d\x1aC\x20\ + The\x20app\x20profile\x20which\x20will\x20(partially)\x20replace\x20the\ + \x20current\x20value.\n\n\x0f\n\x05\x04\x13\x02\0\x04\x12\x06\xaf\x03\ + \x02\xad\x03!\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\xaf\x03\x02\x0c\n\r\n\ + \x05\x04\x13\x02\0\x01\x12\x04\xaf\x03\r\x18\n\r\n\x05\x04\x13\x02\0\x03\ + \x12\x04\xaf\x03\x1b\x1c\nr\n\x04\x04\x13\x02\x01\x12\x04\xb3\x03\x02,\ + \x1ad\x20The\x20subset\x20of\x20app\x20profile\x20fields\x20which\x20sho\ + uld\x20be\x20replaced.\n\x20If\x20unset,\x20all\x20fields\x20will\x20be\ + \x20replaced.\n\n\x0f\n\x05\x04\x13\x02\x01\x04\x12\x06\xb3\x03\x02\xaf\ + \x03\x1d\n\r\n\x05\x04\x13\x02\x01\x06\x12\x04\xb3\x03\x02\x1b\n\r\n\x05\ + \x04\x13\x02\x01\x01\x12\x04\xb3\x03\x1c'\n\r\n\x05\x04\x13\x02\x01\x03\ + \x12\x04\xb3\x03*+\nL\n\x04\x04\x13\x02\x02\x12\x04\xb6\x03\x02\x1b\x1a>\ + \x20If\x20true,\x20ignore\x20safety\x20checks\x20when\x20updating\x20the\ + \x20app\x20profile.\n\n\x0f\n\x05\x04\x13\x02\x02\x04\x12\x06\xb6\x03\ + \x02\xb3\x03,\n\r\n\x05\x04\x13\x02\x02\x05\x12\x04\xb6\x03\x02\x06\n\r\ + \n\x05\x04\x13\x02\x02\x01\x12\x04\xb6\x03\x07\x16\n\r\n\x05\x04\x13\x02\ + \x02\x03\x12\x04\xb6\x03\x19\x1a\nK\n\x02\x04\x14\x12\x06\xbb\x03\0\xc2\ + \x03\x01\x1a=\x20Request\x20message\x20for\x20BigtableInstanceAdmin.Dele\ + teAppProfile.\n\n\x0b\n\x03\x04\x14\x01\x12\x04\xbb\x03\x08\x1f\n\x9f\ + \x01\n\x04\x04\x14\x02\0\x12\x04\xbe\x03\x02\x12\x1a\x90\x01\x20The\x20u\ + nique\x20name\x20of\x20the\x20app\x20profile\x20to\x20be\x20deleted.\x20\ + Values\x20are\x20of\x20the\x20form\n\x20`projects//instances//appProfiles/`.\n\n\x0f\n\x05\x04\x14\x02\0\x04\x12\ + \x06\xbe\x03\x02\xbb\x03!\n\r\n\x05\x04\x14\x02\0\x05\x12\x04\xbe\x03\ + \x02\x08\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\xbe\x03\t\r\n\r\n\x05\x04\ + \x14\x02\0\x03\x12\x04\xbe\x03\x10\x11\nL\n\x04\x04\x14\x02\x01\x12\x04\ + \xc1\x03\x02\x1b\x1a>\x20If\x20true,\x20ignore\x20safety\x20checks\x20wh\ + en\x20deleting\x20the\x20app\x20profile.\n\n\x0f\n\x05\x04\x14\x02\x01\ + \x04\x12\x06\xc1\x03\x02\xbe\x03\x12\n\r\n\x05\x04\x14\x02\x01\x05\x12\ + \x04\xc1\x03\x02\x06\n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\xc1\x03\x07\ + \x16\n\r\n\x05\x04\x14\x02\x01\x03\x12\x04\xc1\x03\x19\x1a\nL\n\x02\x04\ + \x15\x12\x06\xc5\x03\0\xc7\x03\x01\x1a>\x20The\x20metadata\x20for\x20the\ + \x20Operation\x20returned\x20by\x20UpdateAppProfile.\n\n\x0b\n\x03\x04\ + \x15\x01\x12\x04\xc5\x03\x08\x20b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin_grpc.rs new file mode 100644 index 00000000..c4a8d9bb --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_instance_admin_grpc.rs @@ -0,0 +1,575 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/CreateInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_GET_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/GetInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_INSTANCES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/ListInstances", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/UpdateInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_PARTIAL_UPDATE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/PartialUpdateInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/DeleteInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/CreateCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_GET_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/GetCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_CLUSTERS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/ListClusters", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/UpdateCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_CLUSTER: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/DeleteCluster", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_APP_PROFILE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/CreateAppProfile", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_GET_APP_PROFILE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/GetAppProfile", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_APP_PROFILES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/ListAppProfiles", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_APP_PROFILE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/UpdateAppProfile", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_APP_PROFILE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/DeleteAppProfile", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_GET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/GetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_SET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/SetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableInstanceAdmin/TestIamPermissions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableInstanceAdminClient { + client: ::grpcio::Client, +} + +impl BigtableInstanceAdminClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableInstanceAdminClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_instance_opt(&self, req: &super::bigtable_instance_admin::CreateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_INSTANCE, req, opt) + } + + pub fn create_instance(&self, req: &super::bigtable_instance_admin::CreateInstanceRequest) -> ::grpcio::Result { + self.create_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_instance_async_opt(&self, req: &super::bigtable_instance_admin::CreateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_INSTANCE, req, opt) + } + + pub fn create_instance_async(&self, req: &super::bigtable_instance_admin::CreateInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_opt(&self, req: &super::bigtable_instance_admin::GetInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_INSTANCE, req, opt) + } + + pub fn get_instance(&self, req: &super::bigtable_instance_admin::GetInstanceRequest) -> ::grpcio::Result { + self.get_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_async_opt(&self, req: &super::bigtable_instance_admin::GetInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_INSTANCE, req, opt) + } + + pub fn get_instance_async(&self, req: &super::bigtable_instance_admin::GetInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_instances_opt(&self, req: &super::bigtable_instance_admin::ListInstancesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_INSTANCES, req, opt) + } + + pub fn list_instances(&self, req: &super::bigtable_instance_admin::ListInstancesRequest) -> ::grpcio::Result { + self.list_instances_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_instances_async_opt(&self, req: &super::bigtable_instance_admin::ListInstancesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_INSTANCES, req, opt) + } + + pub fn list_instances_async(&self, req: &super::bigtable_instance_admin::ListInstancesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_instances_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_instance_opt(&self, req: &super::instance::Instance, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_INSTANCE, req, opt) + } + + pub fn update_instance(&self, req: &super::instance::Instance) -> ::grpcio::Result { + self.update_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_instance_async_opt(&self, req: &super::instance::Instance, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_INSTANCE, req, opt) + } + + pub fn update_instance_async(&self, req: &super::instance::Instance) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partial_update_instance_opt(&self, req: &super::bigtable_instance_admin::PartialUpdateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_PARTIAL_UPDATE_INSTANCE, req, opt) + } + + pub fn partial_update_instance(&self, req: &super::bigtable_instance_admin::PartialUpdateInstanceRequest) -> ::grpcio::Result { + self.partial_update_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partial_update_instance_async_opt(&self, req: &super::bigtable_instance_admin::PartialUpdateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_PARTIAL_UPDATE_INSTANCE, req, opt) + } + + pub fn partial_update_instance_async(&self, req: &super::bigtable_instance_admin::PartialUpdateInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.partial_update_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_instance_opt(&self, req: &super::bigtable_instance_admin::DeleteInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_INSTANCE, req, opt) + } + + pub fn delete_instance(&self, req: &super::bigtable_instance_admin::DeleteInstanceRequest) -> ::grpcio::Result { + self.delete_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_instance_async_opt(&self, req: &super::bigtable_instance_admin::DeleteInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_INSTANCE, req, opt) + } + + pub fn delete_instance_async(&self, req: &super::bigtable_instance_admin::DeleteInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_cluster_opt(&self, req: &super::bigtable_instance_admin::CreateClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_CLUSTER, req, opt) + } + + pub fn create_cluster(&self, req: &super::bigtable_instance_admin::CreateClusterRequest) -> ::grpcio::Result { + self.create_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_cluster_async_opt(&self, req: &super::bigtable_instance_admin::CreateClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_CLUSTER, req, opt) + } + + pub fn create_cluster_async(&self, req: &super::bigtable_instance_admin::CreateClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_cluster_opt(&self, req: &super::bigtable_instance_admin::GetClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_CLUSTER, req, opt) + } + + pub fn get_cluster(&self, req: &super::bigtable_instance_admin::GetClusterRequest) -> ::grpcio::Result { + self.get_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_cluster_async_opt(&self, req: &super::bigtable_instance_admin::GetClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_CLUSTER, req, opt) + } + + pub fn get_cluster_async(&self, req: &super::bigtable_instance_admin::GetClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_clusters_opt(&self, req: &super::bigtable_instance_admin::ListClustersRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_CLUSTERS, req, opt) + } + + pub fn list_clusters(&self, req: &super::bigtable_instance_admin::ListClustersRequest) -> ::grpcio::Result { + self.list_clusters_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_clusters_async_opt(&self, req: &super::bigtable_instance_admin::ListClustersRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_CLUSTERS, req, opt) + } + + pub fn list_clusters_async(&self, req: &super::bigtable_instance_admin::ListClustersRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_clusters_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_cluster_opt(&self, req: &super::instance::Cluster, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_CLUSTER, req, opt) + } + + pub fn update_cluster(&self, req: &super::instance::Cluster) -> ::grpcio::Result { + self.update_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_cluster_async_opt(&self, req: &super::instance::Cluster, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_CLUSTER, req, opt) + } + + pub fn update_cluster_async(&self, req: &super::instance::Cluster) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_cluster_opt(&self, req: &super::bigtable_instance_admin::DeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_CLUSTER, req, opt) + } + + pub fn delete_cluster(&self, req: &super::bigtable_instance_admin::DeleteClusterRequest) -> ::grpcio::Result { + self.delete_cluster_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_cluster_async_opt(&self, req: &super::bigtable_instance_admin::DeleteClusterRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_CLUSTER, req, opt) + } + + pub fn delete_cluster_async(&self, req: &super::bigtable_instance_admin::DeleteClusterRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_cluster_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_app_profile_opt(&self, req: &super::bigtable_instance_admin::CreateAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_APP_PROFILE, req, opt) + } + + pub fn create_app_profile(&self, req: &super::bigtable_instance_admin::CreateAppProfileRequest) -> ::grpcio::Result { + self.create_app_profile_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_app_profile_async_opt(&self, req: &super::bigtable_instance_admin::CreateAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_APP_PROFILE, req, opt) + } + + pub fn create_app_profile_async(&self, req: &super::bigtable_instance_admin::CreateAppProfileRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_app_profile_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_app_profile_opt(&self, req: &super::bigtable_instance_admin::GetAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_APP_PROFILE, req, opt) + } + + pub fn get_app_profile(&self, req: &super::bigtable_instance_admin::GetAppProfileRequest) -> ::grpcio::Result { + self.get_app_profile_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_app_profile_async_opt(&self, req: &super::bigtable_instance_admin::GetAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_APP_PROFILE, req, opt) + } + + pub fn get_app_profile_async(&self, req: &super::bigtable_instance_admin::GetAppProfileRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_app_profile_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_app_profiles_opt(&self, req: &super::bigtable_instance_admin::ListAppProfilesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_APP_PROFILES, req, opt) + } + + pub fn list_app_profiles(&self, req: &super::bigtable_instance_admin::ListAppProfilesRequest) -> ::grpcio::Result { + self.list_app_profiles_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_app_profiles_async_opt(&self, req: &super::bigtable_instance_admin::ListAppProfilesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_APP_PROFILES, req, opt) + } + + pub fn list_app_profiles_async(&self, req: &super::bigtable_instance_admin::ListAppProfilesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_app_profiles_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_app_profile_opt(&self, req: &super::bigtable_instance_admin::UpdateAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_APP_PROFILE, req, opt) + } + + pub fn update_app_profile(&self, req: &super::bigtable_instance_admin::UpdateAppProfileRequest) -> ::grpcio::Result { + self.update_app_profile_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_app_profile_async_opt(&self, req: &super::bigtable_instance_admin::UpdateAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_APP_PROFILE, req, opt) + } + + pub fn update_app_profile_async(&self, req: &super::bigtable_instance_admin::UpdateAppProfileRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_app_profile_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_app_profile_opt(&self, req: &super::bigtable_instance_admin::DeleteAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_APP_PROFILE, req, opt) + } + + pub fn delete_app_profile(&self, req: &super::bigtable_instance_admin::DeleteAppProfileRequest) -> ::grpcio::Result { + self.delete_app_profile_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_app_profile_async_opt(&self, req: &super::bigtable_instance_admin::DeleteAppProfileRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_APP_PROFILE, req, opt) + } + + pub fn delete_app_profile_async(&self, req: &super::bigtable_instance_admin::DeleteAppProfileRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_app_profile_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result { + self.get_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_async_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy_async(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result { + self.set_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_async_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy_async(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.set_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result { + self.test_iam_permissions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_async_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions_async(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.test_iam_permissions_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait BigtableInstanceAdmin { + fn create_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::CreateInstanceRequest, sink: ::grpcio::UnarySink); + fn get_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::GetInstanceRequest, sink: ::grpcio::UnarySink); + fn list_instances(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::ListInstancesRequest, sink: ::grpcio::UnarySink); + fn update_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::instance::Instance, sink: ::grpcio::UnarySink); + fn partial_update_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::PartialUpdateInstanceRequest, sink: ::grpcio::UnarySink); + fn delete_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::DeleteInstanceRequest, sink: ::grpcio::UnarySink); + fn create_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::CreateClusterRequest, sink: ::grpcio::UnarySink); + fn get_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::GetClusterRequest, sink: ::grpcio::UnarySink); + fn list_clusters(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::ListClustersRequest, sink: ::grpcio::UnarySink); + fn update_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::instance::Cluster, sink: ::grpcio::UnarySink); + fn delete_cluster(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::DeleteClusterRequest, sink: ::grpcio::UnarySink); + fn create_app_profile(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::CreateAppProfileRequest, sink: ::grpcio::UnarySink); + fn get_app_profile(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::GetAppProfileRequest, sink: ::grpcio::UnarySink); + fn list_app_profiles(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::ListAppProfilesRequest, sink: ::grpcio::UnarySink); + fn update_app_profile(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::UpdateAppProfileRequest, sink: ::grpcio::UnarySink); + fn delete_app_profile(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_instance_admin::DeleteAppProfileRequest, sink: ::grpcio::UnarySink); + fn get_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::GetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn set_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::SetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn test_iam_permissions(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::TestIamPermissionsRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable_instance_admin(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_INSTANCE, move |ctx, req, resp| { + instance.create_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_INSTANCE, move |ctx, req, resp| { + instance.get_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_INSTANCES, move |ctx, req, resp| { + instance.list_instances(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_INSTANCE, move |ctx, req, resp| { + instance.update_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_PARTIAL_UPDATE_INSTANCE, move |ctx, req, resp| { + instance.partial_update_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_INSTANCE, move |ctx, req, resp| { + instance.delete_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_CLUSTER, move |ctx, req, resp| { + instance.create_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_CLUSTER, move |ctx, req, resp| { + instance.get_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_CLUSTERS, move |ctx, req, resp| { + instance.list_clusters(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_CLUSTER, move |ctx, req, resp| { + instance.update_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_CLUSTER, move |ctx, req, resp| { + instance.delete_cluster(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_CREATE_APP_PROFILE, move |ctx, req, resp| { + instance.create_app_profile(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_APP_PROFILE, move |ctx, req, resp| { + instance.get_app_profile(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_LIST_APP_PROFILES, move |ctx, req, resp| { + instance.list_app_profiles(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_UPDATE_APP_PROFILE, move |ctx, req, resp| { + instance.update_app_profile(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_DELETE_APP_PROFILE, move |ctx, req, resp| { + instance.delete_app_profile(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_GET_IAM_POLICY, move |ctx, req, resp| { + instance.get_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_SET_IAM_POLICY, move |ctx, req, resp| { + instance.set_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, move |ctx, req, resp| { + instance.test_iam_permissions(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin.rs new file mode 100644 index 00000000..0282feae --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin.rs @@ -0,0 +1,5704 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/v2/bigtable_table_admin.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct CreateTableRequest { + // message fields + pub parent: ::std::string::String, + pub table_id: ::std::string::String, + pub table: ::protobuf::SingularPtrField, + pub initial_splits: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateTableRequest { + fn default() -> &'a CreateTableRequest { + ::default_instance() + } +} + +impl CreateTableRequest { + pub fn new() -> CreateTableRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string table_id = 2; + + + pub fn get_table_id(&self) -> &str { + &self.table_id + } + pub fn clear_table_id(&mut self) { + self.table_id.clear(); + } + + // Param is passed by value, moved + pub fn set_table_id(&mut self, v: ::std::string::String) { + self.table_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_id(&mut self) -> &mut ::std::string::String { + &mut self.table_id + } + + // Take field + pub fn take_table_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_id, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Table table = 3; + + + pub fn get_table(&self) -> &super::table::Table { + self.table.as_ref().unwrap_or_else(|| super::table::Table::default_instance()) + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + pub fn has_table(&self) -> bool { + self.table.is_some() + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: super::table::Table) { + self.table = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut super::table::Table { + if self.table.is_none() { + self.table.set_default(); + } + self.table.as_mut().unwrap() + } + + // Take field + pub fn take_table(&mut self) -> super::table::Table { + self.table.take().unwrap_or_else(|| super::table::Table::new()) + } + + // repeated .google.bigtable.admin.v2.CreateTableRequest.Split initial_splits = 4; + + + pub fn get_initial_splits(&self) -> &[CreateTableRequest_Split] { + &self.initial_splits + } + pub fn clear_initial_splits(&mut self) { + self.initial_splits.clear(); + } + + // Param is passed by value, moved + pub fn set_initial_splits(&mut self, v: ::protobuf::RepeatedField) { + self.initial_splits = v; + } + + // Mutable pointer to the field. + pub fn mut_initial_splits(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.initial_splits + } + + // Take field + pub fn take_initial_splits(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.initial_splits, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CreateTableRequest { + fn is_initialized(&self) -> bool { + for v in &self.table { + if !v.is_initialized() { + return false; + } + }; + for v in &self.initial_splits { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.table)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.initial_splits)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.table_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.table_id); + } + if let Some(ref v) = self.table.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.initial_splits { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.table_id.is_empty() { + os.write_string(2, &self.table_id)?; + } + if let Some(ref v) = self.table.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.initial_splits { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateTableRequest { + CreateTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateTableRequest| { &m.parent }, + |m: &mut CreateTableRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_id", + |m: &CreateTableRequest| { &m.table_id }, + |m: &mut CreateTableRequest| { &mut m.table_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "table", + |m: &CreateTableRequest| { &m.table }, + |m: &mut CreateTableRequest| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "initial_splits", + |m: &CreateTableRequest| { &m.initial_splits }, + |m: &mut CreateTableRequest| { &mut m.initial_splits }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateTableRequest, + }; + unsafe { + instance.get(CreateTableRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateTableRequest { + fn clear(&mut self) { + self.parent.clear(); + self.table_id.clear(); + self.table.clear(); + self.initial_splits.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateTableRequest_Split { + // message fields + pub key: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateTableRequest_Split { + fn default() -> &'a CreateTableRequest_Split { + ::default_instance() + } +} + +impl CreateTableRequest_Split { + pub fn new() -> CreateTableRequest_Split { + ::std::default::Default::default() + } + + // bytes key = 1; + + + pub fn get_key(&self) -> &[u8] { + &self.key + } + pub fn clear_key(&mut self) { + self.key.clear(); + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::vec::Vec) { + self.key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.key + } + + // Take field + pub fn take_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.key, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for CreateTableRequest_Split { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.key); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.key.is_empty() { + os.write_bytes(1, &self.key)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateTableRequest_Split { + CreateTableRequest_Split::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "key", + |m: &CreateTableRequest_Split| { &m.key }, + |m: &mut CreateTableRequest_Split| { &mut m.key }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateTableRequest_Split", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateTableRequest_Split { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateTableRequest_Split, + }; + unsafe { + instance.get(CreateTableRequest_Split::new) + } + } +} + +impl ::protobuf::Clear for CreateTableRequest_Split { + fn clear(&mut self) { + self.key.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateTableRequest_Split { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateTableRequest_Split { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateTableFromSnapshotRequest { + // message fields + pub parent: ::std::string::String, + pub table_id: ::std::string::String, + pub source_snapshot: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateTableFromSnapshotRequest { + fn default() -> &'a CreateTableFromSnapshotRequest { + ::default_instance() + } +} + +impl CreateTableFromSnapshotRequest { + pub fn new() -> CreateTableFromSnapshotRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string table_id = 2; + + + pub fn get_table_id(&self) -> &str { + &self.table_id + } + pub fn clear_table_id(&mut self) { + self.table_id.clear(); + } + + // Param is passed by value, moved + pub fn set_table_id(&mut self, v: ::std::string::String) { + self.table_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_id(&mut self) -> &mut ::std::string::String { + &mut self.table_id + } + + // Take field + pub fn take_table_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_id, ::std::string::String::new()) + } + + // string source_snapshot = 3; + + + pub fn get_source_snapshot(&self) -> &str { + &self.source_snapshot + } + pub fn clear_source_snapshot(&mut self) { + self.source_snapshot.clear(); + } + + // Param is passed by value, moved + pub fn set_source_snapshot(&mut self, v: ::std::string::String) { + self.source_snapshot = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_snapshot(&mut self) -> &mut ::std::string::String { + &mut self.source_snapshot + } + + // Take field + pub fn take_source_snapshot(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.source_snapshot, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for CreateTableFromSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.source_snapshot)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.table_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.table_id); + } + if !self.source_snapshot.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.source_snapshot); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.table_id.is_empty() { + os.write_string(2, &self.table_id)?; + } + if !self.source_snapshot.is_empty() { + os.write_string(3, &self.source_snapshot)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateTableFromSnapshotRequest { + CreateTableFromSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateTableFromSnapshotRequest| { &m.parent }, + |m: &mut CreateTableFromSnapshotRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_id", + |m: &CreateTableFromSnapshotRequest| { &m.table_id }, + |m: &mut CreateTableFromSnapshotRequest| { &mut m.table_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "source_snapshot", + |m: &CreateTableFromSnapshotRequest| { &m.source_snapshot }, + |m: &mut CreateTableFromSnapshotRequest| { &mut m.source_snapshot }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateTableFromSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateTableFromSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateTableFromSnapshotRequest, + }; + unsafe { + instance.get(CreateTableFromSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateTableFromSnapshotRequest { + fn clear(&mut self) { + self.parent.clear(); + self.table_id.clear(); + self.source_snapshot.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateTableFromSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateTableFromSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DropRowRangeRequest { + // message fields + pub name: ::std::string::String, + // message oneof groups + pub target: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DropRowRangeRequest { + fn default() -> &'a DropRowRangeRequest { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum DropRowRangeRequest_oneof_target { + row_key_prefix(::std::vec::Vec), + delete_all_data_from_table(bool), +} + +impl DropRowRangeRequest { + pub fn new() -> DropRowRangeRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // bytes row_key_prefix = 2; + + + pub fn get_row_key_prefix(&self) -> &[u8] { + match self.target { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(ref v)) => v, + _ => &[], + } + } + pub fn clear_row_key_prefix(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_row_key_prefix(&self) -> bool { + match self.target { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_key_prefix(&mut self, v: ::std::vec::Vec) { + self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_key_prefix(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(::std::vec::Vec::new())); + } + match self.target { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_key_prefix(&mut self) -> ::std::vec::Vec { + if self.has_row_key_prefix() { + match self.target.take() { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bool delete_all_data_from_table = 3; + + + pub fn get_delete_all_data_from_table(&self) -> bool { + match self.target { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(v)) => v, + _ => false, + } + } + pub fn clear_delete_all_data_from_table(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_delete_all_data_from_table(&self) -> bool { + match self.target { + ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_all_data_from_table(&mut self, v: bool) { + self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(v)) + } +} + +impl ::protobuf::Message for DropRowRangeRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &DropRowRangeRequest_oneof_target::row_key_prefix(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &DropRowRangeRequest_oneof_target::delete_all_data_from_table(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &DropRowRangeRequest_oneof_target::row_key_prefix(ref v) => { + os.write_bytes(2, v)?; + }, + &DropRowRangeRequest_oneof_target::delete_all_data_from_table(v) => { + os.write_bool(3, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DropRowRangeRequest { + DropRowRangeRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DropRowRangeRequest| { &m.name }, + |m: &mut DropRowRangeRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "row_key_prefix", + DropRowRangeRequest::has_row_key_prefix, + DropRowRangeRequest::get_row_key_prefix, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "delete_all_data_from_table", + DropRowRangeRequest::has_delete_all_data_from_table, + DropRowRangeRequest::get_delete_all_data_from_table, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DropRowRangeRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DropRowRangeRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DropRowRangeRequest, + }; + unsafe { + instance.get(DropRowRangeRequest::new) + } + } +} + +impl ::protobuf::Clear for DropRowRangeRequest { + fn clear(&mut self) { + self.name.clear(); + self.target = ::std::option::Option::None; + self.target = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DropRowRangeRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DropRowRangeRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTablesRequest { + // message fields + pub parent: ::std::string::String, + pub view: super::table::Table_View, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTablesRequest { + fn default() -> &'a ListTablesRequest { + ::default_instance() + } +} + +impl ListTablesRequest { + pub fn new() -> ListTablesRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Table.View view = 2; + + + pub fn get_view(&self) -> super::table::Table_View { + self.view + } + pub fn clear_view(&mut self) { + self.view = super::table::Table_View::VIEW_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_view(&mut self, v: super::table::Table_View) { + self.view = v; + } + + // int32 page_size = 4; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTablesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)? + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.view != super::table::Table_View::VIEW_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(2, self.view); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(4, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.view != super::table::Table_View::VIEW_UNSPECIFIED { + os.write_enum(2, self.view.value())?; + } + if self.page_size != 0 { + os.write_int32(4, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTablesRequest { + ListTablesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListTablesRequest| { &m.parent }, + |m: &mut ListTablesRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "view", + |m: &ListTablesRequest| { &m.view }, + |m: &mut ListTablesRequest| { &mut m.view }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTablesRequest| { &m.page_size }, + |m: &mut ListTablesRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTablesRequest| { &m.page_token }, + |m: &mut ListTablesRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTablesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTablesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTablesRequest, + }; + unsafe { + instance.get(ListTablesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTablesRequest { + fn clear(&mut self) { + self.parent.clear(); + self.view = super::table::Table_View::VIEW_UNSPECIFIED; + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTablesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTablesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTablesResponse { + // message fields + pub tables: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTablesResponse { + fn default() -> &'a ListTablesResponse { + ::default_instance() + } +} + +impl ListTablesResponse { + pub fn new() -> ListTablesResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.Table tables = 1; + + + pub fn get_tables(&self) -> &[super::table::Table] { + &self.tables + } + pub fn clear_tables(&mut self) { + self.tables.clear(); + } + + // Param is passed by value, moved + pub fn set_tables(&mut self, v: ::protobuf::RepeatedField) { + self.tables = v; + } + + // Mutable pointer to the field. + pub fn mut_tables(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.tables + } + + // Take field + pub fn take_tables(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.tables, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTablesResponse { + fn is_initialized(&self) -> bool { + for v in &self.tables { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.tables)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.tables { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.tables { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTablesResponse { + ListTablesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "tables", + |m: &ListTablesResponse| { &m.tables }, + |m: &mut ListTablesResponse| { &mut m.tables }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTablesResponse| { &m.next_page_token }, + |m: &mut ListTablesResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTablesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTablesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTablesResponse, + }; + unsafe { + instance.get(ListTablesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTablesResponse { + fn clear(&mut self) { + self.tables.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTablesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTablesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetTableRequest { + // message fields + pub name: ::std::string::String, + pub view: super::table::Table_View, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetTableRequest { + fn default() -> &'a GetTableRequest { + ::default_instance() + } +} + +impl GetTableRequest { + pub fn new() -> GetTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Table.View view = 2; + + + pub fn get_view(&self) -> super::table::Table_View { + self.view + } + pub fn clear_view(&mut self) { + self.view = super::table::Table_View::VIEW_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_view(&mut self, v: super::table::Table_View) { + self.view = v; + } +} + +impl ::protobuf::Message for GetTableRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if self.view != super::table::Table_View::VIEW_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(2, self.view); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if self.view != super::table::Table_View::VIEW_UNSPECIFIED { + os.write_enum(2, self.view.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetTableRequest { + GetTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetTableRequest| { &m.name }, + |m: &mut GetTableRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "view", + |m: &GetTableRequest| { &m.view }, + |m: &mut GetTableRequest| { &mut m.view }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetTableRequest, + }; + unsafe { + instance.get(GetTableRequest::new) + } + } +} + +impl ::protobuf::Clear for GetTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.view = super::table::Table_View::VIEW_UNSPECIFIED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteTableRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteTableRequest { + fn default() -> &'a DeleteTableRequest { + ::default_instance() + } +} + +impl DeleteTableRequest { + pub fn new() -> DeleteTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteTableRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteTableRequest { + DeleteTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteTableRequest| { &m.name }, + |m: &mut DeleteTableRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteTableRequest, + }; + unsafe { + instance.get(DeleteTableRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyColumnFamiliesRequest { + // message fields + pub name: ::std::string::String, + pub modifications: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyColumnFamiliesRequest { + fn default() -> &'a ModifyColumnFamiliesRequest { + ::default_instance() + } +} + +impl ModifyColumnFamiliesRequest { + pub fn new() -> ModifyColumnFamiliesRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.bigtable.admin.v2.ModifyColumnFamiliesRequest.Modification modifications = 2; + + + pub fn get_modifications(&self) -> &[ModifyColumnFamiliesRequest_Modification] { + &self.r#modifications + } + pub fn clear_modifications(&mut self) { + self.r#modifications.clear(); + } + + // Param is passed by value, moved + pub fn set_modifications(&mut self, v: ::protobuf::RepeatedField) { + self.r#modifications = v; + } + + // Mutable pointer to the field. + pub fn mut_modifications(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.r#modifications + } + + // Take field + pub fn take_modifications(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.r#modifications, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ModifyColumnFamiliesRequest { + fn is_initialized(&self) -> bool { + for v in &self.r#modifications { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.r#modifications)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.r#modifications { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.r#modifications { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyColumnFamiliesRequest { + ModifyColumnFamiliesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ModifyColumnFamiliesRequest| { &m.name }, + |m: &mut ModifyColumnFamiliesRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "modifications", + |m: &ModifyColumnFamiliesRequest| { &m.modifications }, + |m: &mut ModifyColumnFamiliesRequest| { &mut m.modifications }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyColumnFamiliesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyColumnFamiliesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyColumnFamiliesRequest, + }; + unsafe { + instance.get(ModifyColumnFamiliesRequest::new) + } + } +} + +impl ::protobuf::Clear for ModifyColumnFamiliesRequest { + fn clear(&mut self) { + self.name.clear(); + self.r#modifications.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyColumnFamiliesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyColumnFamiliesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyColumnFamiliesRequest_Modification { + // message fields + pub id: ::std::string::String, + // message oneof groups + pub r#mod: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyColumnFamiliesRequest_Modification { + fn default() -> &'a ModifyColumnFamiliesRequest_Modification { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ModifyColumnFamiliesRequest_Modification_oneof_mod { + create(super::table::ColumnFamily), + update(super::table::ColumnFamily), + drop(bool), +} + +impl ModifyColumnFamiliesRequest_Modification { + pub fn new() -> ModifyColumnFamiliesRequest_Modification { + ::std::default::Default::default() + } + + // string id = 1; + + + pub fn get_id(&self) -> &str { + &self.id + } + pub fn clear_id(&mut self) { + self.id.clear(); + } + + // Param is passed by value, moved + pub fn set_id(&mut self, v: ::std::string::String) { + self.id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_id(&mut self) -> &mut ::std::string::String { + &mut self.id + } + + // Take field + pub fn take_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.id, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.ColumnFamily create = 2; + + + pub fn get_create(&self) -> &super::table::ColumnFamily { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v)) => v, + _ => super::table::ColumnFamily::default_instance(), + } + } + pub fn clear_create(&mut self) { + self.r#mod = ::std::option::Option::None; + } + + pub fn has_create(&self) -> bool { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_create(&mut self, v: super::table::ColumnFamily) { + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(v)) + } + + // Mutable pointer to the field. + pub fn mut_create(&mut self) -> &mut super::table::ColumnFamily { + if let ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(_)) = self.r#mod { + } else { + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(super::table::ColumnFamily::new())); + } + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_create(&mut self) -> super::table::ColumnFamily { + if self.has_create() { + match self.r#mod.take() { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(v)) => v, + _ => panic!(), + } + } else { + super::table::ColumnFamily::new() + } + } + + // .google.bigtable.admin.v2.ColumnFamily update = 3; + + + pub fn get_update(&self) -> &super::table::ColumnFamily { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v)) => v, + _ => super::table::ColumnFamily::default_instance(), + } + } + pub fn clear_update(&mut self) { + self.r#mod = ::std::option::Option::None; + } + + pub fn has_update(&self) -> bool { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_update(&mut self, v: super::table::ColumnFamily) { + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(v)) + } + + // Mutable pointer to the field. + pub fn mut_update(&mut self) -> &mut super::table::ColumnFamily { + if let ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(_)) = self.r#mod { + } else { + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(super::table::ColumnFamily::new())); + } + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_update(&mut self) -> super::table::ColumnFamily { + if self.has_update() { + match self.r#mod.take() { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(v)) => v, + _ => panic!(), + } + } else { + super::table::ColumnFamily::new() + } + } + + // bool drop = 4; + + + pub fn get_drop(&self) -> bool { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v)) => v, + _ => false, + } + } + pub fn clear_drop(&mut self) { + self.r#mod = ::std::option::Option::None; + } + + pub fn has_drop(&self) -> bool { + match self.r#mod { + ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_drop(&mut self, v: bool) { + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v)) + } +} + +impl ::protobuf::Message for ModifyColumnFamiliesRequest_Modification { + fn is_initialized(&self) -> bool { + if let Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v)) = self.r#mod { + if !v.is_initialized() { + return false; + } + } + if let Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v)) = self.r#mod { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.r#mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.id); + } + if let ::std::option::Option::Some(ref v) = self.r#mod { + match v { + &ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.id.is_empty() { + os.write_string(1, &self.id)?; + } + if let ::std::option::Option::Some(ref v) = self.r#mod { + match v { + &ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v) => { + os.write_bool(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyColumnFamiliesRequest_Modification { + ModifyColumnFamiliesRequest_Modification::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "id", + |m: &ModifyColumnFamiliesRequest_Modification| { &m.id }, + |m: &mut ModifyColumnFamiliesRequest_Modification| { &mut m.id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::table::ColumnFamily>( + "create", + ModifyColumnFamiliesRequest_Modification::has_create, + ModifyColumnFamiliesRequest_Modification::get_create, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::table::ColumnFamily>( + "update", + ModifyColumnFamiliesRequest_Modification::has_update, + ModifyColumnFamiliesRequest_Modification::get_update, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "drop", + ModifyColumnFamiliesRequest_Modification::has_drop, + ModifyColumnFamiliesRequest_Modification::get_drop, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyColumnFamiliesRequest_Modification", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyColumnFamiliesRequest_Modification { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyColumnFamiliesRequest_Modification, + }; + unsafe { + instance.get(ModifyColumnFamiliesRequest_Modification::new) + } + } +} + +impl ::protobuf::Clear for ModifyColumnFamiliesRequest_Modification { + fn clear(&mut self) { + self.id.clear(); + self.r#mod = ::std::option::Option::None; + self.r#mod = ::std::option::Option::None; + self.r#mod = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyColumnFamiliesRequest_Modification { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyColumnFamiliesRequest_Modification { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GenerateConsistencyTokenRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GenerateConsistencyTokenRequest { + fn default() -> &'a GenerateConsistencyTokenRequest { + ::default_instance() + } +} + +impl GenerateConsistencyTokenRequest { + pub fn new() -> GenerateConsistencyTokenRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GenerateConsistencyTokenRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GenerateConsistencyTokenRequest { + GenerateConsistencyTokenRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GenerateConsistencyTokenRequest| { &m.name }, + |m: &mut GenerateConsistencyTokenRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GenerateConsistencyTokenRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GenerateConsistencyTokenRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GenerateConsistencyTokenRequest, + }; + unsafe { + instance.get(GenerateConsistencyTokenRequest::new) + } + } +} + +impl ::protobuf::Clear for GenerateConsistencyTokenRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GenerateConsistencyTokenRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GenerateConsistencyTokenRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GenerateConsistencyTokenResponse { + // message fields + pub consistency_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GenerateConsistencyTokenResponse { + fn default() -> &'a GenerateConsistencyTokenResponse { + ::default_instance() + } +} + +impl GenerateConsistencyTokenResponse { + pub fn new() -> GenerateConsistencyTokenResponse { + ::std::default::Default::default() + } + + // string consistency_token = 1; + + + pub fn get_consistency_token(&self) -> &str { + &self.consistency_token + } + pub fn clear_consistency_token(&mut self) { + self.consistency_token.clear(); + } + + // Param is passed by value, moved + pub fn set_consistency_token(&mut self, v: ::std::string::String) { + self.consistency_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_consistency_token(&mut self) -> &mut ::std::string::String { + &mut self.consistency_token + } + + // Take field + pub fn take_consistency_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.consistency_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GenerateConsistencyTokenResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.consistency_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.consistency_token.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.consistency_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.consistency_token.is_empty() { + os.write_string(1, &self.consistency_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GenerateConsistencyTokenResponse { + GenerateConsistencyTokenResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "consistency_token", + |m: &GenerateConsistencyTokenResponse| { &m.consistency_token }, + |m: &mut GenerateConsistencyTokenResponse| { &mut m.consistency_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GenerateConsistencyTokenResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GenerateConsistencyTokenResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GenerateConsistencyTokenResponse, + }; + unsafe { + instance.get(GenerateConsistencyTokenResponse::new) + } + } +} + +impl ::protobuf::Clear for GenerateConsistencyTokenResponse { + fn clear(&mut self) { + self.consistency_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GenerateConsistencyTokenResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GenerateConsistencyTokenResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckConsistencyRequest { + // message fields + pub name: ::std::string::String, + pub consistency_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckConsistencyRequest { + fn default() -> &'a CheckConsistencyRequest { + ::default_instance() + } +} + +impl CheckConsistencyRequest { + pub fn new() -> CheckConsistencyRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string consistency_token = 2; + + + pub fn get_consistency_token(&self) -> &str { + &self.consistency_token + } + pub fn clear_consistency_token(&mut self) { + self.consistency_token.clear(); + } + + // Param is passed by value, moved + pub fn set_consistency_token(&mut self, v: ::std::string::String) { + self.consistency_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_consistency_token(&mut self) -> &mut ::std::string::String { + &mut self.consistency_token + } + + // Take field + pub fn take_consistency_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.consistency_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for CheckConsistencyRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.consistency_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.consistency_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.consistency_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.consistency_token.is_empty() { + os.write_string(2, &self.consistency_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckConsistencyRequest { + CheckConsistencyRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CheckConsistencyRequest| { &m.name }, + |m: &mut CheckConsistencyRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "consistency_token", + |m: &CheckConsistencyRequest| { &m.consistency_token }, + |m: &mut CheckConsistencyRequest| { &mut m.consistency_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckConsistencyRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckConsistencyRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckConsistencyRequest, + }; + unsafe { + instance.get(CheckConsistencyRequest::new) + } + } +} + +impl ::protobuf::Clear for CheckConsistencyRequest { + fn clear(&mut self) { + self.name.clear(); + self.consistency_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckConsistencyRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckConsistencyRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckConsistencyResponse { + // message fields + pub consistent: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckConsistencyResponse { + fn default() -> &'a CheckConsistencyResponse { + ::default_instance() + } +} + +impl CheckConsistencyResponse { + pub fn new() -> CheckConsistencyResponse { + ::std::default::Default::default() + } + + // bool consistent = 1; + + + pub fn get_consistent(&self) -> bool { + self.consistent + } + pub fn clear_consistent(&mut self) { + self.consistent = false; + } + + // Param is passed by value, moved + pub fn set_consistent(&mut self, v: bool) { + self.consistent = v; + } +} + +impl ::protobuf::Message for CheckConsistencyResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.consistent = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.consistent != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.consistent != false { + os.write_bool(1, self.consistent)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckConsistencyResponse { + CheckConsistencyResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "consistent", + |m: &CheckConsistencyResponse| { &m.consistent }, + |m: &mut CheckConsistencyResponse| { &mut m.consistent }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckConsistencyResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckConsistencyResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckConsistencyResponse, + }; + unsafe { + instance.get(CheckConsistencyResponse::new) + } + } +} + +impl ::protobuf::Clear for CheckConsistencyResponse { + fn clear(&mut self) { + self.consistent = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckConsistencyResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckConsistencyResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SnapshotTableRequest { + // message fields + pub name: ::std::string::String, + pub cluster: ::std::string::String, + pub snapshot_id: ::std::string::String, + pub ttl: ::protobuf::SingularPtrField<::protobuf::well_known_types::Duration>, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SnapshotTableRequest { + fn default() -> &'a SnapshotTableRequest { + ::default_instance() + } +} + +impl SnapshotTableRequest { + pub fn new() -> SnapshotTableRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string cluster = 2; + + + pub fn get_cluster(&self) -> &str { + &self.cluster + } + pub fn clear_cluster(&mut self) { + self.cluster.clear(); + } + + // Param is passed by value, moved + pub fn set_cluster(&mut self, v: ::std::string::String) { + self.cluster = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster(&mut self) -> &mut ::std::string::String { + &mut self.cluster + } + + // Take field + pub fn take_cluster(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.cluster, ::std::string::String::new()) + } + + // string snapshot_id = 3; + + + pub fn get_snapshot_id(&self) -> &str { + &self.snapshot_id + } + pub fn clear_snapshot_id(&mut self) { + self.snapshot_id.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshot_id(&mut self, v: ::std::string::String) { + self.snapshot_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_snapshot_id(&mut self) -> &mut ::std::string::String { + &mut self.snapshot_id + } + + // Take field + pub fn take_snapshot_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.snapshot_id, ::std::string::String::new()) + } + + // .google.protobuf.Duration ttl = 4; + + + pub fn get_ttl(&self) -> &::protobuf::well_known_types::Duration { + self.ttl.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Duration::default_instance()) + } + pub fn clear_ttl(&mut self) { + self.ttl.clear(); + } + + pub fn has_ttl(&self) -> bool { + self.ttl.is_some() + } + + // Param is passed by value, moved + pub fn set_ttl(&mut self, v: ::protobuf::well_known_types::Duration) { + self.ttl = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ttl(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if self.ttl.is_none() { + self.ttl.set_default(); + } + self.ttl.as_mut().unwrap() + } + + // Take field + pub fn take_ttl(&mut self) -> ::protobuf::well_known_types::Duration { + self.ttl.take().unwrap_or_else(|| ::protobuf::well_known_types::Duration::new()) + } + + // string description = 5; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for SnapshotTableRequest { + fn is_initialized(&self) -> bool { + for v in &self.ttl { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cluster)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.snapshot_id)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ttl)?; + }, + 5 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.cluster.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.cluster); + } + if !self.snapshot_id.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.snapshot_id); + } + if let Some(ref v) = self.ttl.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(5, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.cluster.is_empty() { + os.write_string(2, &self.cluster)?; + } + if !self.snapshot_id.is_empty() { + os.write_string(3, &self.snapshot_id)?; + } + if let Some(ref v) = self.ttl.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.description.is_empty() { + os.write_string(5, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SnapshotTableRequest { + SnapshotTableRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &SnapshotTableRequest| { &m.name }, + |m: &mut SnapshotTableRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "cluster", + |m: &SnapshotTableRequest| { &m.cluster }, + |m: &mut SnapshotTableRequest| { &mut m.cluster }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "snapshot_id", + |m: &SnapshotTableRequest| { &m.snapshot_id }, + |m: &mut SnapshotTableRequest| { &mut m.snapshot_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Duration>>( + "ttl", + |m: &SnapshotTableRequest| { &m.ttl }, + |m: &mut SnapshotTableRequest| { &mut m.ttl }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &SnapshotTableRequest| { &m.description }, + |m: &mut SnapshotTableRequest| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SnapshotTableRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SnapshotTableRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SnapshotTableRequest, + }; + unsafe { + instance.get(SnapshotTableRequest::new) + } + } +} + +impl ::protobuf::Clear for SnapshotTableRequest { + fn clear(&mut self) { + self.name.clear(); + self.cluster.clear(); + self.snapshot_id.clear(); + self.ttl.clear(); + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SnapshotTableRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SnapshotTableRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetSnapshotRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetSnapshotRequest { + fn default() -> &'a GetSnapshotRequest { + ::default_instance() + } +} + +impl GetSnapshotRequest { + pub fn new() -> GetSnapshotRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetSnapshotRequest { + GetSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetSnapshotRequest| { &m.name }, + |m: &mut GetSnapshotRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetSnapshotRequest, + }; + unsafe { + instance.get(GetSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for GetSnapshotRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSnapshotsRequest { + // message fields + pub parent: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSnapshotsRequest { + fn default() -> &'a ListSnapshotsRequest { + ::default_instance() + } +} + +impl ListSnapshotsRequest { + pub fn new() -> ListSnapshotsRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSnapshotsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSnapshotsRequest { + ListSnapshotsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListSnapshotsRequest| { &m.parent }, + |m: &mut ListSnapshotsRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListSnapshotsRequest| { &m.page_size }, + |m: &mut ListSnapshotsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListSnapshotsRequest| { &m.page_token }, + |m: &mut ListSnapshotsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSnapshotsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSnapshotsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSnapshotsRequest, + }; + unsafe { + instance.get(ListSnapshotsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListSnapshotsRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSnapshotsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSnapshotsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSnapshotsResponse { + // message fields + pub snapshots: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSnapshotsResponse { + fn default() -> &'a ListSnapshotsResponse { + ::default_instance() + } +} + +impl ListSnapshotsResponse { + pub fn new() -> ListSnapshotsResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.Snapshot snapshots = 1; + + + pub fn get_snapshots(&self) -> &[super::table::Snapshot] { + &self.snapshots + } + pub fn clear_snapshots(&mut self) { + self.snapshots.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshots(&mut self, v: ::protobuf::RepeatedField) { + self.snapshots = v; + } + + // Mutable pointer to the field. + pub fn mut_snapshots(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.snapshots + } + + // Take field + pub fn take_snapshots(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.snapshots, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSnapshotsResponse { + fn is_initialized(&self) -> bool { + for v in &self.snapshots { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.snapshots)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.snapshots { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.snapshots { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSnapshotsResponse { + ListSnapshotsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "snapshots", + |m: &ListSnapshotsResponse| { &m.snapshots }, + |m: &mut ListSnapshotsResponse| { &mut m.snapshots }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListSnapshotsResponse| { &m.next_page_token }, + |m: &mut ListSnapshotsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSnapshotsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSnapshotsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSnapshotsResponse, + }; + unsafe { + instance.get(ListSnapshotsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListSnapshotsResponse { + fn clear(&mut self) { + self.snapshots.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSnapshotsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSnapshotsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteSnapshotRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteSnapshotRequest { + fn default() -> &'a DeleteSnapshotRequest { + ::default_instance() + } +} + +impl DeleteSnapshotRequest { + pub fn new() -> DeleteSnapshotRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteSnapshotRequest { + DeleteSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteSnapshotRequest| { &m.name }, + |m: &mut DeleteSnapshotRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteSnapshotRequest, + }; + unsafe { + instance.get(DeleteSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteSnapshotRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SnapshotTableMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SnapshotTableMetadata { + fn default() -> &'a SnapshotTableMetadata { + ::default_instance() + } +} + +impl SnapshotTableMetadata { + pub fn new() -> SnapshotTableMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.SnapshotTableRequest original_request = 1; + + + pub fn get_original_request(&self) -> &SnapshotTableRequest { + self.original_request.as_ref().unwrap_or_else(|| SnapshotTableRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: SnapshotTableRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut SnapshotTableRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> SnapshotTableRequest { + self.original_request.take().unwrap_or_else(|| SnapshotTableRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for SnapshotTableMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SnapshotTableMetadata { + SnapshotTableMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &SnapshotTableMetadata| { &m.original_request }, + |m: &mut SnapshotTableMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &SnapshotTableMetadata| { &m.request_time }, + |m: &mut SnapshotTableMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &SnapshotTableMetadata| { &m.finish_time }, + |m: &mut SnapshotTableMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SnapshotTableMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SnapshotTableMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SnapshotTableMetadata, + }; + unsafe { + instance.get(SnapshotTableMetadata::new) + } + } +} + +impl ::protobuf::Clear for SnapshotTableMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SnapshotTableMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SnapshotTableMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateTableFromSnapshotMetadata { + // message fields + pub original_request: ::protobuf::SingularPtrField, + pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateTableFromSnapshotMetadata { + fn default() -> &'a CreateTableFromSnapshotMetadata { + ::default_instance() + } +} + +impl CreateTableFromSnapshotMetadata { + pub fn new() -> CreateTableFromSnapshotMetadata { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.CreateTableFromSnapshotRequest original_request = 1; + + + pub fn get_original_request(&self) -> &CreateTableFromSnapshotRequest { + self.original_request.as_ref().unwrap_or_else(|| CreateTableFromSnapshotRequest::default_instance()) + } + pub fn clear_original_request(&mut self) { + self.original_request.clear(); + } + + pub fn has_original_request(&self) -> bool { + self.original_request.is_some() + } + + // Param is passed by value, moved + pub fn set_original_request(&mut self, v: CreateTableFromSnapshotRequest) { + self.original_request = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_original_request(&mut self) -> &mut CreateTableFromSnapshotRequest { + if self.original_request.is_none() { + self.original_request.set_default(); + } + self.original_request.as_mut().unwrap() + } + + // Take field + pub fn take_original_request(&mut self) -> CreateTableFromSnapshotRequest { + self.original_request.take().unwrap_or_else(|| CreateTableFromSnapshotRequest::new()) + } + + // .google.protobuf.Timestamp request_time = 2; + + + pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.request_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_request_time(&mut self) { + self.request_time.clear(); + } + + pub fn has_request_time(&self) -> bool { + self.request_time.is_some() + } + + // Param is passed by value, moved + pub fn set_request_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.request_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.request_time.is_none() { + self.request_time.set_default(); + } + self.request_time.as_mut().unwrap() + } + + // Take field + pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp finish_time = 3; + + + pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.finish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_finish_time(&mut self) { + self.finish_time.clear(); + } + + pub fn has_finish_time(&self) -> bool { + self.finish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_finish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.finish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_finish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.finish_time.is_none() { + self.finish_time.set_default(); + } + self.finish_time.as_mut().unwrap() + } + + // Take field + pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CreateTableFromSnapshotMetadata { + fn is_initialized(&self) -> bool { + for v in &self.original_request { + if !v.is_initialized() { + return false; + } + }; + for v in &self.request_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.finish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.original_request)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.original_request.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.request_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.finish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.original_request.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.request_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.finish_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateTableFromSnapshotMetadata { + CreateTableFromSnapshotMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "original_request", + |m: &CreateTableFromSnapshotMetadata| { &m.original_request }, + |m: &mut CreateTableFromSnapshotMetadata| { &mut m.original_request }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "request_time", + |m: &CreateTableFromSnapshotMetadata| { &m.request_time }, + |m: &mut CreateTableFromSnapshotMetadata| { &mut m.request_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "finish_time", + |m: &CreateTableFromSnapshotMetadata| { &m.finish_time }, + |m: &mut CreateTableFromSnapshotMetadata| { &mut m.finish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateTableFromSnapshotMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateTableFromSnapshotMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateTableFromSnapshotMetadata, + }; + unsafe { + instance.get(CreateTableFromSnapshotMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateTableFromSnapshotMetadata { + fn clear(&mut self) { + self.original_request.clear(); + self.request_time.clear(); + self.finish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateTableFromSnapshotMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateTableFromSnapshotMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n3google/bigtable/admin/v2/bigtable_table_admin.proto\x12\x18google.big\ + table.admin.v2\x1a\x1cgoogle/api/annotations.proto\x1a$google/bigtable/a\ + dmin/v2/table.proto\x1a#google/longrunning/operations.proto\x1a\x1egoogl\ + e/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoog\ + le/protobuf/timestamp.proto\"\xf4\x01\n\x12CreateTableRequest\x12\x16\n\ + \x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x19\n\x08table_id\x18\x02\ + \x20\x01(\tR\x07tableId\x125\n\x05table\x18\x03\x20\x01(\x0b2\x1f.google\ + .bigtable.admin.v2.TableR\x05table\x12Y\n\x0einitial_splits\x18\x04\x20\ + \x03(\x0b22.google.bigtable.admin.v2.CreateTableRequest.SplitR\rinitialS\ + plits\x1a\x19\n\x05Split\x12\x10\n\x03key\x18\x01\x20\x01(\x0cR\x03key\"\ + |\n\x1eCreateTableFromSnapshotRequest\x12\x16\n\x06parent\x18\x01\x20\ + \x01(\tR\x06parent\x12\x19\n\x08table_id\x18\x02\x20\x01(\tR\x07tableId\ + \x12'\n\x0fsource_snapshot\x18\x03\x20\x01(\tR\x0esourceSnapshot\"\x99\ + \x01\n\x13DropRowRangeRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\ + ame\x12&\n\x0erow_key_prefix\x18\x02\x20\x01(\x0cH\0R\x0crowKeyPrefix\ + \x12<\n\x1adelete_all_data_from_table\x18\x03\x20\x01(\x08H\0R\x16delete\ + AllDataFromTableB\x08\n\x06target\"\xa1\x01\n\x11ListTablesRequest\x12\ + \x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x128\n\x04view\x18\x02\ + \x20\x01(\x0e2$.google.bigtable.admin.v2.Table.ViewR\x04view\x12\x1b\n\t\ + page_size\x18\x04\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\ + \x03\x20\x01(\tR\tpageToken\"u\n\x12ListTablesResponse\x127\n\x06tables\ + \x18\x01\x20\x03(\x0b2\x1f.google.bigtable.admin.v2.TableR\x06tables\x12\ + &\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"_\n\x0fGetTab\ + leRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x128\n\x04view\ + \x18\x02\x20\x01(\x0e2$.google.bigtable.admin.v2.Table.ViewR\x04view\"(\ + \n\x12DeleteTableRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\ + \xdd\x02\n\x1bModifyColumnFamiliesRequest\x12\x12\n\x04name\x18\x01\x20\ + \x01(\tR\x04name\x12h\n\rmodifications\x18\x02\x20\x03(\x0b2B.google.big\ + table.admin.v2.ModifyColumnFamiliesRequest.ModificationR\rmodifications\ + \x1a\xbf\x01\n\x0cModification\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\ + \x12@\n\x06create\x18\x02\x20\x01(\x0b2&.google.bigtable.admin.v2.Column\ + FamilyH\0R\x06create\x12@\n\x06update\x18\x03\x20\x01(\x0b2&.google.bigt\ + able.admin.v2.ColumnFamilyH\0R\x06update\x12\x14\n\x04drop\x18\x04\x20\ + \x01(\x08H\0R\x04dropB\x05\n\x03mod\"5\n\x1fGenerateConsistencyTokenRequ\ + est\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"O\n\x20GenerateConsis\ + tencyTokenResponse\x12+\n\x11consistency_token\x18\x01\x20\x01(\tR\x10co\ + nsistencyToken\"Z\n\x17CheckConsistencyRequest\x12\x12\n\x04name\x18\x01\ + \x20\x01(\tR\x04name\x12+\n\x11consistency_token\x18\x02\x20\x01(\tR\x10\ + consistencyToken\":\n\x18CheckConsistencyResponse\x12\x1e\n\nconsistent\ + \x18\x01\x20\x01(\x08R\nconsistent\"\xb4\x01\n\x14SnapshotTableRequest\ + \x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07cluster\x18\ + \x02\x20\x01(\tR\x07cluster\x12\x1f\n\x0bsnapshot_id\x18\x03\x20\x01(\tR\ + \nsnapshotId\x12+\n\x03ttl\x18\x04\x20\x01(\x0b2\x19.google.protobuf.Dur\ + ationR\x03ttl\x12\x20\n\x0bdescription\x18\x05\x20\x01(\tR\x0bdescriptio\ + n\"(\n\x12GetSnapshotRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04na\ + me\"j\n\x14ListSnapshotsRequest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\ + \x06parent\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\ + \x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\x81\x01\n\x15ListSna\ + pshotsResponse\x12@\n\tsnapshots\x18\x01\x20\x03(\x0b2\".google.bigtable\ + .admin.v2.SnapshotR\tsnapshots\x12&\n\x0fnext_page_token\x18\x02\x20\x01\ + (\tR\rnextPageToken\"+\n\x15DeleteSnapshotRequest\x12\x12\n\x04name\x18\ + \x01\x20\x01(\tR\x04name\"\xee\x01\n\x15SnapshotTableMetadata\x12Y\n\x10\ + original_request\x18\x01\x20\x01(\x0b2..google.bigtable.admin.v2.Snapsho\ + tTableRequestR\x0foriginalRequest\x12=\n\x0crequest_time\x18\x02\x20\x01\ + (\x0b2\x1a.google.protobuf.TimestampR\x0brequestTime\x12;\n\x0bfinish_ti\ + me\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nfinishTime\"\ + \x82\x02\n\x1fCreateTableFromSnapshotMetadata\x12c\n\x10original_request\ + \x18\x01\x20\x01(\x0b28.google.bigtable.admin.v2.CreateTableFromSnapshot\ + RequestR\x0foriginalRequest\x12=\n\x0crequest_time\x18\x02\x20\x01(\x0b2\ + \x1a.google.protobuf.TimestampR\x0brequestTime\x12;\n\x0bfinish_time\x18\ + \x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nfinishTime2\xb7\x11\n\ + \x12BigtableTableAdmin\x12\x93\x01\n\x0bCreateTable\x12,.google.bigtable\ + .admin.v2.CreateTableRequest\x1a\x1f.google.bigtable.admin.v2.Table\"5\ + \x82\xd3\xe4\x93\x02/\"*/v2/{parent=projects/*/instances/*}/tables:\x01*\ + \x12\xbc\x01\n\x17CreateTableFromSnapshot\x128.google.bigtable.admin.v2.\ + CreateTableFromSnapshotRequest\x1a\x1d.google.longrunning.Operation\"H\ + \x82\xd3\xe4\x93\x02B\"=/v2/{parent=projects/*/instances/*}/tables:creat\ + eFromSnapshot:\x01*\x12\x9b\x01\n\nListTables\x12+.google.bigtable.admin\ + .v2.ListTablesRequest\x1a,.google.bigtable.admin.v2.ListTablesResponse\"\ + 2\x82\xd3\xe4\x93\x02,\x12*/v2/{parent=projects/*/instances/*}/tables\ + \x12\x8a\x01\n\x08GetTable\x12).google.bigtable.admin.v2.GetTableRequest\ + \x1a\x1f.google.bigtable.admin.v2.Table\"2\x82\xd3\xe4\x93\x02,\x12*/v2/\ + {name=projects/*/instances/*/tables/*}\x12\x87\x01\n\x0bDeleteTable\x12,\ + .google.bigtable.admin.v2.DeleteTableRequest\x1a\x16.google.protobuf.Emp\ + ty\"2\x82\xd3\xe4\x93\x02,**/v2/{name=projects/*/instances/*/tables/*}\ + \x12\xba\x01\n\x14ModifyColumnFamilies\x125.google.bigtable.admin.v2.Mod\ + ifyColumnFamiliesRequest\x1a\x1f.google.bigtable.admin.v2.Table\"J\x82\ + \xd3\xe4\x93\x02D\"?/v2/{name=projects/*/instances/*/tables/*}:modifyCol\ + umnFamilies:\x01*\x12\x99\x01\n\x0cDropRowRange\x12-.google.bigtable.adm\ + in.v2.DropRowRangeRequest\x1a\x16.google.protobuf.Empty\"B\x82\xd3\xe4\ + \x93\x02<\"7/v2/{name=projects/*/instances/*/tables/*}:dropRowRange:\x01\ + *\x12\xe1\x01\n\x18GenerateConsistencyToken\x129.google.bigtable.admin.v\ + 2.GenerateConsistencyTokenRequest\x1a:.google.bigtable.admin.v2.Generate\ + ConsistencyTokenResponse\"N\x82\xd3\xe4\x93\x02H\"C/v2/{name=projects/*/\ + instances/*/tables/*}:generateConsistencyToken:\x01*\x12\xc1\x01\n\x10Ch\ + eckConsistency\x121.google.bigtable.admin.v2.CheckConsistencyRequest\x1a\ + 2.google.bigtable.admin.v2.CheckConsistencyResponse\"F\x82\xd3\xe4\x93\ + \x02@\";/v2/{name=projects/*/instances/*/tables/*}:checkConsistency:\x01\ + *\x12\x9e\x01\n\rSnapshotTable\x12..google.bigtable.admin.v2.SnapshotTab\ + leRequest\x1a\x1d.google.longrunning.Operation\">\x82\xd3\xe4\x93\x028\"\ + 3/v2/{name=projects/*/instances/*/tables/*}:snapshot:\x01*\x12\xa1\x01\n\ + \x0bGetSnapshot\x12,.google.bigtable.admin.v2.GetSnapshotRequest\x1a\".g\ + oogle.bigtable.admin.v2.Snapshot\"@\x82\xd3\xe4\x93\x02:\x128/v2/{name=p\ + rojects/*/instances/*/clusters/*/snapshots/*}\x12\xb2\x01\n\rListSnapsho\ + ts\x12..google.bigtable.admin.v2.ListSnapshotsRequest\x1a/.google.bigtab\ + le.admin.v2.ListSnapshotsResponse\"@\x82\xd3\xe4\x93\x02:\x128/v2/{paren\ + t=projects/*/instances/*/clusters/*}/snapshots\x12\x9b\x01\n\x0eDeleteSn\ + apshot\x12/.google.bigtable.admin.v2.DeleteSnapshotRequest\x1a\x16.googl\ + e.protobuf.Empty\"@\x82\xd3\xe4\x93\x02:*8/v2/{name=projects/*/instances\ + /*/clusters/*/snapshots/*}B\xba\x01\n\x1ccom.google.bigtable.admin.v2B\ + \x17BigtableTableAdminProtoP\x01Z=google.golang.org/genproto/googleapis/\ + bigtable/admin/v2;admin\xaa\x02\x1eGoogle.Cloud.Bigtable.Admin.V2\xca\ + \x02\x1eGoogle\\Cloud\\Bigtable\\Admin\\V2J\x8c\xa7\x01\n\x07\x12\x05\ + \x0f\0\x8c\x04\x01\n\xbe\x04\n\x01\x0c\x12\x03\x0f\0\x122\xb3\x04\x20Cop\ + yright\x202018\x20Google\x20LLC.\n\n\x20Licensed\x20under\x20the\x20Apac\ + he\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20ma\ + y\x20not\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\ + \x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\ + \x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/\ + LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\ + \x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\ + \x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20B\ + ASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIN\ + D,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20\ + for\x20the\x20specific\x20language\x20governing\x20permissions\x20and\n\ + \x20limitations\x20under\x20the\x20License.\n\n\n\x08\n\x01\x02\x12\x03\ + \x11\0!\n\t\n\x02\x03\0\x12\x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\x14\0.\ + \n\t\n\x02\x03\x02\x12\x03\x15\0-\n\t\n\x02\x03\x03\x12\x03\x16\0(\n\t\n\ + \x02\x03\x04\x12\x03\x17\0%\n\t\n\x02\x03\x05\x12\x03\x18\0)\n\x08\n\x01\ + \x08\x12\x03\x1a\0;\n\t\n\x02\x08%\x12\x03\x1a\0;\n\x08\n\x01\x08\x12\ + \x03\x1b\0T\n\t\n\x02\x08\x0b\x12\x03\x1b\0T\n\x08\n\x01\x08\x12\x03\x1c\ + \0\"\n\t\n\x02\x08\n\x12\x03\x1c\0\"\n\x08\n\x01\x08\x12\x03\x1d\08\n\t\ + \n\x02\x08\x08\x12\x03\x1d\08\n\x08\n\x01\x08\x12\x03\x1e\05\n\t\n\x02\ + \x08\x01\x12\x03\x1e\05\n\x08\n\x01\x08\x12\x03\x1f\0<\n\t\n\x02\x08)\ + \x12\x03\x1f\0<\n\xac\x01\n\x02\x06\0\x12\x05'\0\xb5\x01\x01\x1a\x9e\x01\ + \x20Service\x20for\x20creating,\x20configuring,\x20and\x20deleting\x20Cl\ + oud\x20Bigtable\x20tables.\n\n\n\x20Provides\x20access\x20to\x20the\x20t\ + able\x20schemas\x20only,\x20not\x20the\x20data\x20stored\x20within\n\x20\ + the\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03'\x08\x1a\n\xa0\x01\n\x04\ + \x06\0\x02\0\x12\x04+\x020\x03\x1a\x91\x01\x20Creates\x20a\x20new\x20tab\ + le\x20in\x20the\x20specified\x20instance.\n\x20The\x20table\x20can\x20be\ + \x20created\x20with\x20a\x20full\x20set\x20of\x20initial\x20column\x20fa\ + milies,\n\x20specified\x20in\x20the\x20request.\n\n\x0c\n\x05\x06\0\x02\ + \0\x01\x12\x03+\x06\x11\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03+\x12$\n\x0c\ + \n\x05\x06\0\x02\0\x03\x12\x03+/4\n\r\n\x05\x06\0\x02\0\x04\x12\x04,\x04\ + /\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04,\x04/\x06\n\xca\ + \x03\n\x04\x06\0\x02\x01\x12\x04:\x02?\x03\x1a\xbb\x03\x20Creates\x20a\ + \x20new\x20table\x20from\x20the\x20specified\x20snapshot.\x20The\x20targ\ + et\x20table\x20must\n\x20not\x20exist.\x20The\x20snapshot\x20and\x20the\ + \x20table\x20must\x20be\x20in\x20the\x20same\x20instance.\n\n\x20Note:\ + \x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Big\ + table\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20av\ + ailable\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20fe\ + ature\x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\ + \x20and\x20is\x20not\n\x20recommended\x20for\x20production\x20use.\x20It\ + \x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\n\x20p\ + olicy.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03:\x06\x1d\n\x0c\n\x05\x06\ + \0\x02\x01\x02\x12\x03:\x1e<\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03:Gc\n\ + \r\n\x05\x06\0\x02\x01\x04\x12\x04;\x04>\x06\n\x11\n\t\x06\0\x02\x01\x04\ + \xb0\xca\xbc\"\x12\x04;\x04>\x06\nB\n\x04\x06\0\x02\x02\x12\x04B\x02F\ + \x03\x1a4\x20Lists\x20all\x20tables\x20served\x20from\x20a\x20specified\ + \x20instance.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03B\x06\x10\n\x0c\n\ + \x05\x06\0\x02\x02\x02\x12\x03B\x11\"\n\x0c\n\x05\x06\0\x02\x02\x03\x12\ + \x03B-?\n\r\n\x05\x06\0\x02\x02\x04\x12\x04C\x04E\x06\n\x11\n\t\x06\0\ + \x02\x02\x04\xb0\xca\xbc\"\x12\x04C\x04E\x06\nD\n\x04\x06\0\x02\x03\x12\ + \x04I\x02M\x03\x1a6\x20Gets\x20metadata\x20information\x20about\x20the\ + \x20specified\x20table.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03I\x06\x0e\ + \n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03I\x0f\x1e\n\x0c\n\x05\x06\0\x02\ + \x03\x03\x12\x03I).\n\r\n\x05\x06\0\x02\x03\x04\x12\x04J\x04L\x06\n\x11\ + \n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04J\x04L\x06\nJ\n\x04\x06\0\ + \x02\x04\x12\x04P\x02T\x03\x1a<\x20Permanently\x20deletes\x20a\x20specif\ + ied\x20table\x20and\x20all\x20of\x20its\x20data.\n\n\x0c\n\x05\x06\0\x02\ + \x04\x01\x12\x03P\x06\x11\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03P\x12$\n\ + \x0c\n\x05\x06\0\x02\x04\x03\x12\x03P/D\n\r\n\x05\x06\0\x02\x04\x04\x12\ + \x04Q\x04S\x06\n\x11\n\t\x06\0\x02\x04\x04\xb0\xca\xbc\"\x12\x04Q\x04S\ + \x06\n\x9b\x02\n\x04\x06\0\x02\x05\x12\x04Z\x02_\x03\x1a\x8c\x02\x20Perf\ + orms\x20a\x20series\x20of\x20column\x20family\x20modifications\x20on\x20\ + the\x20specified\x20table.\n\x20Either\x20all\x20or\x20none\x20of\x20the\ + \x20modifications\x20will\x20occur\x20before\x20this\x20method\n\x20retu\ + rns,\x20but\x20data\x20requests\x20received\x20prior\x20to\x20that\x20po\ + int\x20may\x20see\x20a\x20table\n\x20where\x20only\x20some\x20modificati\ + ons\x20have\x20taken\x20effect.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03Z\ + \x06\x1a\n\x0c\n\x05\x06\0\x02\x05\x02\x12\x03Z\x1b6\n\x0c\n\x05\x06\0\ + \x02\x05\x03\x12\x03ZAF\n\r\n\x05\x06\0\x02\x05\x04\x12\x04[\x04^\x06\n\ + \x11\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\"\x12\x04[\x04^\x06\n\xbb\x01\n\ + \x04\x06\0\x02\x06\x12\x04d\x02i\x03\x1a\xac\x01\x20Permanently\x20drop/\ + delete\x20a\x20row\x20range\x20from\x20a\x20specified\x20table.\x20The\ + \x20request\x20can\n\x20specify\x20whether\x20to\x20delete\x20all\x20row\ + s\x20in\x20a\x20table,\x20or\x20only\x20those\x20that\x20match\x20a\n\ + \x20particular\x20prefix.\n\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03d\x06\ + \x12\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03d\x13&\n\x0c\n\x05\x06\0\x02\ + \x06\x03\x12\x03d1F\n\r\n\x05\x06\0\x02\x06\x04\x12\x04e\x04h\x06\n\x11\ + \n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x04e\x04h\x06\n\xf3\x01\n\x04\ + \x06\0\x02\x07\x12\x04o\x02t\x03\x1a\xe4\x01\x20Generates\x20a\x20consis\ + tency\x20token\x20for\x20a\x20Table,\x20which\x20can\x20be\x20used\x20in\ + \n\x20CheckConsistency\x20to\x20check\x20whether\x20mutations\x20to\x20t\ + he\x20table\x20that\x20finished\n\x20before\x20this\x20call\x20started\ + \x20have\x20been\x20replicated.\x20The\x20tokens\x20will\x20be\x20availa\ + ble\n\x20for\x2090\x20days.\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03o\x06\ + \x1e\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03o\x1f>\n\x0c\n\x05\x06\0\x02\ + \x07\x03\x12\x03oIi\n\r\n\x05\x06\0\x02\x07\x04\x12\x04p\x04s\x06\n\x11\ + \n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x04p\x04s\x06\n\xbb\x01\n\x04\ + \x06\0\x02\x08\x12\x04y\x02~\x03\x1a\xac\x01\x20Checks\x20replication\ + \x20consistency\x20based\x20on\x20a\x20consistency\x20token,\x20that\x20\ + is,\x20if\n\x20replication\x20has\x20caught\x20up\x20based\x20on\x20the\ + \x20conditions\x20specified\x20in\x20the\x20token\n\x20and\x20the\x20che\ + ck\x20request.\n\n\x0c\n\x05\x06\0\x02\x08\x01\x12\x03y\x06\x16\n\x0c\n\ + \x05\x06\0\x02\x08\x02\x12\x03y\x17.\n\x0c\n\x05\x06\0\x02\x08\x03\x12\ + \x03y9Q\n\r\n\x05\x06\0\x02\x08\x04\x12\x04z\x04}\x06\n\x11\n\t\x06\0\ + \x02\x08\x04\xb0\xca\xbc\"\x12\x04z\x04}\x06\n\xca\x03\n\x04\x06\0\x02\t\ + \x12\x06\x88\x01\x02\x8d\x01\x03\x1a\xb9\x03\x20Creates\x20a\x20new\x20s\ + napshot\x20in\x20the\x20specified\x20cluster\x20from\x20the\x20specified\ + \n\x20source\x20table.\x20The\x20cluster\x20and\x20the\x20table\x20must\ + \x20be\x20in\x20the\x20same\x20instance.\n\n\x20Note:\x20This\x20is\x20a\ + \x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\ + \x20This\n\x20feature\x20is\x20not\x20currently\x20available\x20to\x20mo\ + st\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20b\ + e\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\ + \n\x20recommended\x20for\x20production\x20use.\x20It\x20is\x20not\x20sub\ + ject\x20to\x20any\x20SLA\x20or\x20deprecation\n\x20policy.\n\n\r\n\x05\ + \x06\0\x02\t\x01\x12\x04\x88\x01\x06\x13\n\r\n\x05\x06\0\x02\t\x02\x12\ + \x04\x88\x01\x14(\n\r\n\x05\x06\0\x02\t\x03\x12\x04\x88\x013O\n\x0f\n\ + \x05\x06\0\x02\t\x04\x12\x06\x89\x01\x04\x8c\x01\x06\n\x13\n\t\x06\0\x02\ + \t\x04\xb0\xca\xbc\"\x12\x06\x89\x01\x04\x8c\x01\x06\n\xf8\x02\n\x04\x06\ + \0\x02\n\x12\x06\x96\x01\x02\x9a\x01\x03\x1a\xe7\x02\x20Gets\x20metadata\ + \x20information\x20about\x20the\x20specified\x20snapshot.\n\n\x20Note:\ + \x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Big\ + table\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20av\ + ailable\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20fe\ + ature\x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\ + \x20and\x20is\x20not\n\x20recommended\x20for\x20production\x20use.\x20It\ + \x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\n\x20p\ + olicy.\n\n\r\n\x05\x06\0\x02\n\x01\x12\x04\x96\x01\x06\x11\n\r\n\x05\x06\ + \0\x02\n\x02\x12\x04\x96\x01\x12$\n\r\n\x05\x06\0\x02\n\x03\x12\x04\x96\ + \x01/7\n\x0f\n\x05\x06\0\x02\n\x04\x12\x06\x97\x01\x04\x99\x01\x06\n\x13\ + \n\t\x06\0\x02\n\x04\xb0\xca\xbc\"\x12\x06\x97\x01\x04\x99\x01\x06\n\xfb\ + \x02\n\x04\x06\0\x02\x0b\x12\x06\xa3\x01\x02\xa7\x01\x03\x1a\xea\x02\x20\ + Lists\x20all\x20snapshots\x20associated\x20with\x20the\x20specified\x20c\ + luster.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\ + \x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20\ + not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20cust\ + omers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-\ + incompatible\x20ways\x20and\x20is\x20not\n\x20recommended\x20for\x20prod\ + uction\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\ + \x20deprecation\n\x20policy.\n\n\r\n\x05\x06\0\x02\x0b\x01\x12\x04\xa3\ + \x01\x06\x13\n\r\n\x05\x06\0\x02\x0b\x02\x12\x04\xa3\x01\x14(\n\r\n\x05\ + \x06\0\x02\x0b\x03\x12\x04\xa3\x013H\n\x0f\n\x05\x06\0\x02\x0b\x04\x12\ + \x06\xa4\x01\x04\xa6\x01\x06\n\x13\n\t\x06\0\x02\x0b\x04\xb0\xca\xbc\"\ + \x12\x06\xa4\x01\x04\xa6\x01\x06\n\xec\x02\n\x04\x06\0\x02\x0c\x12\x06\ + \xb0\x01\x02\xb4\x01\x03\x1a\xdb\x02\x20Permanently\x20deletes\x20the\ + \x20specified\x20snapshot.\n\n\x20Note:\x20This\x20is\x20a\x20private\ + \x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\ + \x20feature\x20is\x20not\x20currently\x20available\x20to\x20most\x20Clou\ + d\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20be\x20chang\ + ed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\n\x20recom\ + mended\x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\ + \x20any\x20SLA\x20or\x20deprecation\n\x20policy.\n\n\r\n\x05\x06\0\x02\ + \x0c\x01\x12\x04\xb0\x01\x06\x14\n\r\n\x05\x06\0\x02\x0c\x02\x12\x04\xb0\ + \x01\x15*\n\r\n\x05\x06\0\x02\x0c\x03\x12\x04\xb0\x015J\n\x0f\n\x05\x06\ + \0\x02\x0c\x04\x12\x06\xb1\x01\x04\xb3\x01\x06\n\x13\n\t\x06\0\x02\x0c\ + \x04\xb0\xca\xbc\"\x12\x06\xb1\x01\x04\xb3\x01\x06\n\x98\x01\n\x02\x04\0\ + \x12\x06\xb9\x01\0\xdc\x01\x01\x1a\x89\x01\x20Request\x20message\x20for\ + \n\x20[google.bigtable.admin.v2.BigtableTableAdmin.CreateTable][google.b\ + igtable.admin.v2.BigtableTableAdmin.CreateTable]\n\n\x0b\n\x03\x04\0\x01\ + \x12\x04\xb9\x01\x08\x1a\nC\n\x04\x04\0\x03\0\x12\x06\xbb\x01\x02\xbe\ + \x01\x03\x1a3\x20An\x20initial\x20split\x20point\x20for\x20a\x20newly\ + \x20created\x20table.\n\n\r\n\x05\x04\0\x03\0\x01\x12\x04\xbb\x01\n\x0f\ + \n?\n\x06\x04\0\x03\0\x02\0\x12\x04\xbd\x01\x04\x12\x1a/\x20Row\x20key\ + \x20to\x20use\x20as\x20an\x20initial\x20tablet\x20boundary.\n\n\x11\n\ + \x07\x04\0\x03\0\x02\0\x04\x12\x06\xbd\x01\x04\xbb\x01\x11\n\x0f\n\x07\ + \x04\0\x03\0\x02\0\x05\x12\x04\xbd\x01\x04\t\n\x0f\n\x07\x04\0\x03\0\x02\ + \0\x01\x12\x04\xbd\x01\n\r\n\x0f\n\x07\x04\0\x03\0\x02\0\x03\x12\x04\xbd\ + \x01\x10\x11\n\x91\x01\n\x04\x04\0\x02\0\x12\x04\xc2\x01\x02\x14\x1a\x82\ + \x01\x20The\x20unique\x20name\x20of\x20the\x20instance\x20in\x20which\ + \x20to\x20create\x20the\x20table.\n\x20Values\x20are\x20of\x20the\x20for\ + m\x20`projects//instances/`.\n\n\x0f\n\x05\x04\0\x02\ + \0\x04\x12\x06\xc2\x01\x02\xbe\x01\x03\n\r\n\x05\x04\0\x02\0\x05\x12\x04\ + \xc2\x01\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xc2\x01\t\x0f\n\r\n\ + \x05\x04\0\x02\0\x03\x12\x04\xc2\x01\x12\x13\n\x98\x01\n\x04\x04\0\x02\ + \x01\x12\x04\xc6\x01\x02\x16\x1a\x89\x01\x20The\x20name\x20by\x20which\ + \x20the\x20new\x20table\x20should\x20be\x20referred\x20to\x20within\x20t\ + he\x20parent\n\x20instance,\x20e.g.,\x20`foobar`\x20rather\x20than\x20`<\ + parent>/tables/foobar`.\n\n\x0f\n\x05\x04\0\x02\x01\x04\x12\x06\xc6\x01\ + \x02\xc2\x01\x14\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\xc6\x01\x02\x08\n\r\ + \n\x05\x04\0\x02\x01\x01\x12\x04\xc6\x01\t\x11\n\r\n\x05\x04\0\x02\x01\ + \x03\x12\x04\xc6\x01\x14\x15\n$\n\x04\x04\0\x02\x02\x12\x04\xc9\x01\x02\ + \x12\x1a\x16\x20The\x20Table\x20to\x20create.\n\n\x0f\n\x05\x04\0\x02\ + \x02\x04\x12\x06\xc9\x01\x02\xc6\x01\x16\n\r\n\x05\x04\0\x02\x02\x06\x12\ + \x04\xc9\x01\x02\x07\n\r\n\x05\x04\0\x02\x02\x01\x12\x04\xc9\x01\x08\r\n\ + \r\n\x05\x04\0\x02\x02\x03\x12\x04\xc9\x01\x10\x11\n\x99\x06\n\x04\x04\0\ + \x02\x03\x12\x04\xdb\x01\x02$\x1a\x8a\x06\x20The\x20optional\x20list\x20\ + of\x20row\x20keys\x20that\x20will\x20be\x20used\x20to\x20initially\x20sp\ + lit\x20the\n\x20table\x20into\x20several\x20tablets\x20(tablets\x20are\ + \x20similar\x20to\x20HBase\x20regions).\n\x20Given\x20two\x20split\x20ke\ + ys,\x20`s1`\x20and\x20`s2`,\x20three\x20tablets\x20will\x20be\x20created\ + ,\n\x20spanning\x20the\x20key\x20ranges:\x20`[,\x20s1),\x20[s1,\x20s2),\ + \x20[s2,\x20)`.\n\n\x20Example:\n\n\x20*\x20Row\x20keys\x20:=\x20`[\"a\"\ + ,\x20\"apple\",\x20\"custom\",\x20\"customer_1\",\x20\"customer_2\",`\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20`\"other\ + \",\x20\"zz\"]`\n\x20*\x20initial_split_keys\x20:=\x20`[\"apple\",\x20\"\ + customer_1\",\x20\"customer_2\",\x20\"other\"]`\n\x20*\x20Key\x20assignm\ + ent:\n\x20\x20\x20\x20\x20-\x20Tablet\x201\x20`[,\x20apple)\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20=>\x20{\"a\"}.`\n\ + \x20\x20\x20\x20\x20-\x20Tablet\x202\x20`[apple,\x20customer_1)\x20\x20\ + \x20\x20\x20\x20=>\x20{\"apple\",\x20\"custom\"}.`\n\x20\x20\x20\x20\x20\ + -\x20Tablet\x203\x20`[customer_1,\x20customer_2)\x20=>\x20{\"customer_1\ + \"}.`\n\x20\x20\x20\x20\x20-\x20Tablet\x204\x20`[customer_2,\x20other)\ + \x20\x20\x20\x20\x20\x20=>\x20{\"customer_2\"}.`\n\x20\x20\x20\x20\x20-\ + \x20Tablet\x205\x20`[other,\x20)\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20=>\x20{\"other\",\x20\"zz\"}.`\n\n\r\n\x05\x04\0\ + \x02\x03\x04\x12\x04\xdb\x01\x02\n\n\r\n\x05\x04\0\x02\x03\x06\x12\x04\ + \xdb\x01\x0b\x10\n\r\n\x05\x04\0\x02\x03\x01\x12\x04\xdb\x01\x11\x1f\n\r\ + \n\x05\x04\0\x02\x03\x03\x12\x04\xdb\x01\"#\n\xdd\x03\n\x02\x04\x01\x12\ + \x06\xe5\x01\0\xf3\x01\x01\x1a\xce\x03\x20Request\x20message\x20for\n\ + \x20[google.bigtable.admin.v2.BigtableTableAdmin.CreateTableFromSnapshot\ + ][google.bigtable.admin.v2.BigtableTableAdmin.CreateTableFromSnapshot]\n\ + \n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20C\ + loud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20curr\ + ently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20T\ + his\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-incompatibl\ + e\x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20production\x20u\ + se.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecati\ + on\x20policy.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xe5\x01\x08&\n\x91\x01\n\ + \x04\x04\x01\x02\0\x12\x04\xe8\x01\x02\x14\x1a\x82\x01\x20The\x20unique\ + \x20name\x20of\x20the\x20instance\x20in\x20which\x20to\x20create\x20the\ + \x20table.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects//instances/`.\n\n\x0f\n\x05\x04\x01\x02\0\x04\x12\x06\xe8\x01\ + \x02\xe5\x01(\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\xe8\x01\x02\x08\n\r\n\ + \x05\x04\x01\x02\0\x01\x12\x04\xe8\x01\t\x0f\n\r\n\x05\x04\x01\x02\0\x03\ + \x12\x04\xe8\x01\x12\x13\n\x98\x01\n\x04\x04\x01\x02\x01\x12\x04\xec\x01\ + \x02\x16\x1a\x89\x01\x20The\x20name\x20by\x20which\x20the\x20new\x20tabl\ + e\x20should\x20be\x20referred\x20to\x20within\x20the\x20parent\n\x20inst\ + ance,\x20e.g.,\x20`foobar`\x20rather\x20than\x20`/tables/foobar`\ + .\n\n\x0f\n\x05\x04\x01\x02\x01\x04\x12\x06\xec\x01\x02\xe8\x01\x14\n\r\ + \n\x05\x04\x01\x02\x01\x05\x12\x04\xec\x01\x02\x08\n\r\n\x05\x04\x01\x02\ + \x01\x01\x12\x04\xec\x01\t\x11\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xec\ + \x01\x14\x15\n\xf7\x01\n\x04\x04\x01\x02\x02\x12\x04\xf2\x01\x02\x1d\x1a\ + \xe8\x01\x20The\x20unique\x20name\x20of\x20the\x20snapshot\x20from\x20wh\ + ich\x20to\x20restore\x20the\x20table.\x20The\n\x20snapshot\x20and\x20the\ + \x20table\x20must\x20be\x20in\x20the\x20same\x20instance.\n\x20Values\ + \x20are\x20of\x20the\x20form\n\x20`projects//instances//clusters//snapshots/`.\n\n\x0f\n\x05\x04\x01\x02\ + \x02\x04\x12\x06\xf2\x01\x02\xec\x01\x16\n\r\n\x05\x04\x01\x02\x02\x05\ + \x12\x04\xf2\x01\x02\x08\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xf2\x01\t\ + \x18\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\xf2\x01\x1b\x1c\n\x9a\x01\n\ + \x02\x04\x02\x12\x06\xf7\x01\0\x86\x02\x01\x1a\x8b\x01\x20Request\x20mes\ + sage\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.DropRowRan\ + ge][google.bigtable.admin.v2.BigtableTableAdmin.DropRowRange]\n\n\x0b\n\ + \x03\x04\x02\x01\x12\x04\xf7\x01\x08\x1b\n\xa2\x01\n\x04\x04\x02\x02\0\ + \x12\x04\xfb\x01\x02\x12\x1a\x93\x01\x20The\x20unique\x20name\x20of\x20t\ + he\x20table\x20on\x20which\x20to\x20drop\x20a\x20range\x20of\x20rows.\n\ + \x20Values\x20are\x20of\x20the\x20form\n\x20`projects//instance\ + s//tables/
`.\n\n\x0f\n\x05\x04\x02\x02\0\x04\x12\x06\ + \xfb\x01\x02\xf7\x01\x1d\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xfb\x01\x02\ + \x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xfb\x01\t\r\n\r\n\x05\x04\x02\ + \x02\0\x03\x12\x04\xfb\x01\x10\x11\n/\n\x04\x04\x02\x08\0\x12\x06\xfe\ + \x01\x02\x85\x02\x03\x1a\x1f\x20Delete\x20all\x20rows\x20or\x20by\x20pre\ + fix.\n\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\xfe\x01\x08\x0e\nc\n\x04\x04\ + \x02\x02\x01\x12\x04\x81\x02\x04\x1d\x1aU\x20Delete\x20all\x20rows\x20th\ + at\x20start\x20with\x20this\x20row\x20key\x20prefix.\x20Prefix\x20cannot\ + \x20be\n\x20zero\x20length.\n\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\x81\ + \x02\x04\t\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\x81\x02\n\x18\n\r\n\x05\ + \x04\x02\x02\x01\x03\x12\x04\x81\x02\x1b\x1c\nO\n\x04\x04\x02\x02\x02\ + \x12\x04\x84\x02\x04(\x1aA\x20Delete\x20all\x20rows\x20in\x20the\x20tabl\ + e.\x20Setting\x20this\x20to\x20false\x20is\x20a\x20no-op.\n\n\r\n\x05\ + \x04\x02\x02\x02\x05\x12\x04\x84\x02\x04\x08\n\r\n\x05\x04\x02\x02\x02\ + \x01\x12\x04\x84\x02\t#\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\x84\x02&'\ + \n\x96\x01\n\x02\x04\x03\x12\x06\x8a\x02\0\x99\x02\x01\x1a\x87\x01\x20Re\ + quest\x20message\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmi\ + n.ListTables][google.bigtable.admin.v2.BigtableTableAdmin.ListTables]\n\ + \n\x0b\n\x03\x04\x03\x01\x12\x04\x8a\x02\x08\x19\n\x96\x01\n\x04\x04\x03\ + \x02\0\x12\x04\x8d\x02\x02\x14\x1a\x87\x01\x20The\x20unique\x20name\x20o\ + f\x20the\x20instance\x20for\x20which\x20tables\x20should\x20be\x20listed\ + .\n\x20Values\x20are\x20of\x20the\x20form\x20`projects//instanc\ + es/`.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\x8d\x02\x02\x8a\ + \x02\x1b\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\x8d\x02\x02\x08\n\r\n\x05\ + \x04\x03\x02\0\x01\x12\x04\x8d\x02\t\x0f\n\r\n\x05\x04\x03\x02\0\x03\x12\ + \x04\x8d\x02\x12\x13\n\x93\x01\n\x04\x04\x03\x02\x01\x12\x04\x91\x02\x02\ + \x16\x1a\x84\x01\x20The\x20view\x20to\x20be\x20applied\x20to\x20the\x20r\ + eturned\x20tables'\x20fields.\n\x20Defaults\x20to\x20`NAME_ONLY`\x20if\ + \x20unspecified;\x20no\x20others\x20are\x20currently\x20supported.\n\n\ + \x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\x91\x02\x02\x8d\x02\x14\n\r\n\x05\ + \x04\x03\x02\x01\x06\x12\x04\x91\x02\x02\x0c\n\r\n\x05\x04\x03\x02\x01\ + \x01\x12\x04\x91\x02\r\x11\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\x91\x02\ + \x14\x15\nY\n\x04\x04\x03\x02\x02\x12\x04\x95\x02\x02\x16\x1aK\x20Maximu\ + m\x20number\x20of\x20results\x20per\x20page.\n\x20CURRENTLY\x20UNIMPLEME\ + NTED\x20AND\x20IGNORED.\n\n\x0f\n\x05\x04\x03\x02\x02\x04\x12\x06\x95\ + \x02\x02\x91\x02\x16\n\r\n\x05\x04\x03\x02\x02\x05\x12\x04\x95\x02\x02\ + \x07\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\x95\x02\x08\x11\n\r\n\x05\x04\ + \x03\x02\x02\x03\x12\x04\x95\x02\x14\x15\nK\n\x04\x04\x03\x02\x03\x12\ + \x04\x98\x02\x02\x18\x1a=\x20The\x20value\x20of\x20`next_page_token`\x20\ + returned\x20by\x20a\x20previous\x20call.\n\n\x0f\n\x05\x04\x03\x02\x03\ + \x04\x12\x06\x98\x02\x02\x95\x02\x16\n\r\n\x05\x04\x03\x02\x03\x05\x12\ + \x04\x98\x02\x02\x08\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\x98\x02\t\x13\ + \n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\x98\x02\x16\x17\n\x97\x01\n\x02\ + \x04\x04\x12\x06\x9d\x02\0\xa5\x02\x01\x1a\x88\x01\x20Response\x20messag\ + e\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.ListTables][g\ + oogle.bigtable.admin.v2.BigtableTableAdmin.ListTables]\n\n\x0b\n\x03\x04\ + \x04\x01\x12\x04\x9d\x02\x08\x1a\n=\n\x04\x04\x04\x02\0\x12\x04\x9f\x02\ + \x02\x1c\x1a/\x20The\x20tables\x20present\x20in\x20the\x20requested\x20i\ + nstance.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\x9f\x02\x02\n\n\r\n\x05\ + \x04\x04\x02\0\x06\x12\x04\x9f\x02\x0b\x10\n\r\n\x05\x04\x04\x02\0\x01\ + \x12\x04\x9f\x02\x11\x17\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\x9f\x02\x1a\ + \x1b\n\xa4\x01\n\x04\x04\x04\x02\x01\x12\x04\xa4\x02\x02\x1d\x1a\x95\x01\ + \x20Set\x20if\x20not\x20all\x20tables\x20could\x20be\x20returned\x20in\ + \x20a\x20single\x20response.\n\x20Pass\x20this\x20value\x20to\x20`page_t\ + oken`\x20in\x20another\x20request\x20to\x20get\x20the\x20next\n\x20page\ + \x20of\x20results.\n\n\x0f\n\x05\x04\x04\x02\x01\x04\x12\x06\xa4\x02\x02\ + \x9f\x02\x1c\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xa4\x02\x02\x08\n\r\n\ + \x05\x04\x04\x02\x01\x01\x12\x04\xa4\x02\t\x18\n\r\n\x05\x04\x04\x02\x01\ + \x03\x12\x04\xa4\x02\x1b\x1c\n\x92\x01\n\x02\x04\x05\x12\x06\xa9\x02\0\ + \xb2\x02\x01\x1a\x83\x01\x20Request\x20message\x20for\n\x20[google.bigta\ + ble.admin.v2.BigtableTableAdmin.GetTable][google.bigtable.admin.v2.Bigta\ + bleTableAdmin.GetTable]\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xa9\x02\x08\ + \x17\n\x8a\x01\n\x04\x04\x05\x02\0\x12\x04\xad\x02\x02\x12\x1a|\x20The\ + \x20unique\x20name\x20of\x20the\x20requested\x20table.\n\x20Values\x20ar\ + e\x20of\x20the\x20form\n\x20`projects//instances//tab\ + les/
`.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\xad\x02\x02\xa9\ + \x02\x19\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xad\x02\x02\x08\n\r\n\x05\ + \x04\x05\x02\0\x01\x12\x04\xad\x02\t\r\n\r\n\x05\x04\x05\x02\0\x03\x12\ + \x04\xad\x02\x10\x11\nq\n\x04\x04\x05\x02\x01\x12\x04\xb1\x02\x02\x16\ + \x1ac\x20The\x20view\x20to\x20be\x20applied\x20to\x20the\x20returned\x20\ + table's\x20fields.\n\x20Defaults\x20to\x20`SCHEMA_VIEW`\x20if\x20unspeci\ + fied.\n\n\x0f\n\x05\x04\x05\x02\x01\x04\x12\x06\xb1\x02\x02\xad\x02\x12\ + \n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\xb1\x02\x02\x0c\n\r\n\x05\x04\x05\ + \x02\x01\x01\x12\x04\xb1\x02\r\x11\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\ + \xb1\x02\x14\x15\n\x98\x01\n\x02\x04\x06\x12\x06\xb6\x02\0\xbb\x02\x01\ + \x1a\x89\x01\x20Request\x20message\x20for\n\x20[google.bigtable.admin.v2\ + .BigtableTableAdmin.DeleteTable][google.bigtable.admin.v2.BigtableTableA\ + dmin.DeleteTable]\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xb6\x02\x08\x1a\n\ + \x8f\x01\n\x04\x04\x06\x02\0\x12\x04\xba\x02\x02\x12\x1a\x80\x01\x20The\ + \x20unique\x20name\x20of\x20the\x20table\x20to\x20be\x20deleted.\n\x20Va\ + lues\x20are\x20of\x20the\x20form\n\x20`projects//instances//tables/
`.\n\n\x0f\n\x05\x04\x06\x02\0\x04\x12\x06\xba\x02\ + \x02\xb6\x02\x1c\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\xba\x02\x02\x08\n\r\ + \n\x05\x04\x06\x02\0\x01\x12\x04\xba\x02\t\r\n\r\n\x05\x04\x06\x02\0\x03\ + \x12\x04\xba\x02\x10\x11\n\xaa\x01\n\x02\x04\x07\x12\x06\xbf\x02\0\xdf\ + \x02\x01\x1a\x9b\x01\x20Request\x20message\x20for\n\x20[google.bigtable.\ + admin.v2.BigtableTableAdmin.ModifyColumnFamilies][google.bigtable.admin.\ + v2.BigtableTableAdmin.ModifyColumnFamilies]\n\n\x0b\n\x03\x04\x07\x01\ + \x12\x04\xbf\x02\x08#\nL\n\x04\x04\x07\x03\0\x12\x06\xc1\x02\x02\xd3\x02\ + \x03\x1a<\x20A\x20create,\x20update,\x20or\x20delete\x20of\x20a\x20parti\ + cular\x20column\x20family.\n\n\r\n\x05\x04\x07\x03\0\x01\x12\x04\xc1\x02\ + \n\x16\n=\n\x06\x04\x07\x03\0\x02\0\x12\x04\xc3\x02\x04\x12\x1a-\x20The\ + \x20ID\x20of\x20the\x20column\x20family\x20to\x20be\x20modified.\n\n\x11\ + \n\x07\x04\x07\x03\0\x02\0\x04\x12\x06\xc3\x02\x04\xc1\x02\x18\n\x0f\n\ + \x07\x04\x07\x03\0\x02\0\x05\x12\x04\xc3\x02\x04\n\n\x0f\n\x07\x04\x07\ + \x03\0\x02\0\x01\x12\x04\xc3\x02\x0b\r\n\x0f\n\x07\x04\x07\x03\0\x02\0\ + \x03\x12\x04\xc3\x02\x10\x11\n1\n\x06\x04\x07\x03\0\x08\0\x12\x06\xc6\ + \x02\x04\xd2\x02\x05\x1a\x1f\x20Column\x20familiy\x20modifications.\n\n\ + \x0f\n\x07\x04\x07\x03\0\x08\0\x01\x12\x04\xc6\x02\n\r\ny\n\x06\x04\x07\ + \x03\0\x02\x01\x12\x04\xc9\x02\x06\x1e\x1ai\x20Create\x20a\x20new\x20col\ + umn\x20family\x20with\x20the\x20specified\x20schema,\x20or\x20fail\x20if\ + \n\x20one\x20already\x20exists\x20with\x20the\x20given\x20ID.\n\n\x0f\n\ + \x07\x04\x07\x03\0\x02\x01\x06\x12\x04\xc9\x02\x06\x12\n\x0f\n\x07\x04\ + \x07\x03\0\x02\x01\x01\x12\x04\xc9\x02\x13\x19\n\x0f\n\x07\x04\x07\x03\0\ + \x02\x01\x03\x12\x04\xc9\x02\x1c\x1d\n\x82\x01\n\x06\x04\x07\x03\0\x02\ + \x02\x12\x04\xcd\x02\x06\x1e\x1ar\x20Update\x20an\x20existing\x20column\ + \x20family\x20to\x20the\x20specified\x20schema,\x20or\x20fail\n\x20if\ + \x20no\x20column\x20family\x20exists\x20with\x20the\x20given\x20ID.\n\n\ + \x0f\n\x07\x04\x07\x03\0\x02\x02\x06\x12\x04\xcd\x02\x06\x12\n\x0f\n\x07\ + \x04\x07\x03\0\x02\x02\x01\x12\x04\xcd\x02\x13\x19\n\x0f\n\x07\x04\x07\ + \x03\0\x02\x02\x03\x12\x04\xcd\x02\x1c\x1d\ng\n\x06\x04\x07\x03\0\x02\ + \x03\x12\x04\xd1\x02\x06\x14\x1aW\x20Drop\x20(delete)\x20the\x20column\ + \x20family\x20with\x20the\x20given\x20ID,\x20or\x20fail\x20if\x20no\x20s\ + uch\n\x20family\x20exists.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x03\x05\x12\ + \x04\xd1\x02\x06\n\n\x0f\n\x07\x04\x07\x03\0\x02\x03\x01\x12\x04\xd1\x02\ + \x0b\x0f\n\x0f\n\x07\x04\x07\x03\0\x02\x03\x03\x12\x04\xd1\x02\x12\x13\n\ + \xa3\x01\n\x04\x04\x07\x02\0\x12\x04\xd8\x02\x02\x12\x1a\x94\x01\x20The\ + \x20unique\x20name\x20of\x20the\x20table\x20whose\x20families\x20should\ + \x20be\x20modified.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projec\ + ts//instances//tables/
`.\n\n\x0f\n\x05\x04\x07\ + \x02\0\x04\x12\x06\xd8\x02\x02\xd3\x02\x03\n\r\n\x05\x04\x07\x02\0\x05\ + \x12\x04\xd8\x02\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xd8\x02\t\r\ + \n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xd8\x02\x10\x11\n\xfd\x01\n\x04\x04\ + \x07\x02\x01\x12\x04\xde\x02\x02*\x1a\xee\x01\x20Modifications\x20to\x20\ + be\x20atomically\x20applied\x20to\x20the\x20specified\x20table's\x20fami\ + lies.\n\x20Entries\x20are\x20applied\x20in\x20order,\x20meaning\x20that\ + \x20earlier\x20modifications\x20can\x20be\n\x20masked\x20by\x20later\x20\ + ones\x20(in\x20the\x20case\x20of\x20repeated\x20updates\x20to\x20the\x20\ + same\x20family,\n\x20for\x20example).\n\n\r\n\x05\x04\x07\x02\x01\x04\ + \x12\x04\xde\x02\x02\n\n\r\n\x05\x04\x07\x02\x01\x06\x12\x04\xde\x02\x0b\ + \x17\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\xde\x02\x18%\n\r\n\x05\x04\ + \x07\x02\x01\x03\x12\x04\xde\x02()\n\xb2\x01\n\x02\x04\x08\x12\x06\xe3\ + \x02\0\xe8\x02\x01\x1a\xa3\x01\x20Request\x20message\x20for\n\x20[google\ + .bigtable.admin.v2.BigtableTableAdmin.GenerateConsistencyToken][google.b\ + igtable.admin.v2.BigtableTableAdmin.GenerateConsistencyToken]\n\n\x0b\n\ + \x03\x04\x08\x01\x12\x04\xe3\x02\x08'\n\xa9\x01\n\x04\x04\x08\x02\0\x12\ + \x04\xe7\x02\x02\x12\x1a\x9a\x01\x20The\x20unique\x20name\x20of\x20the\ + \x20Table\x20for\x20which\x20to\x20create\x20a\x20consistency\x20token.\ + \n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects//instan\ + ces//tables/
`.\n\n\x0f\n\x05\x04\x08\x02\0\x04\x12\x06\ + \xe7\x02\x02\xe3\x02)\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\xe7\x02\x02\ + \x08\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xe7\x02\t\r\n\r\n\x05\x04\x08\ + \x02\0\x03\x12\x04\xe7\x02\x10\x11\n\xb3\x01\n\x02\x04\t\x12\x06\xec\x02\ + \0\xef\x02\x01\x1a\xa4\x01\x20Response\x20message\x20for\n\x20[google.bi\ + gtable.admin.v2.BigtableTableAdmin.GenerateConsistencyToken][google.bigt\ + able.admin.v2.BigtableTableAdmin.GenerateConsistencyToken]\n\n\x0b\n\x03\ + \x04\t\x01\x12\x04\xec\x02\x08(\n0\n\x04\x04\t\x02\0\x12\x04\xee\x02\x02\ + \x1f\x1a\"\x20The\x20generated\x20consistency\x20token.\n\n\x0f\n\x05\ + \x04\t\x02\0\x04\x12\x06\xee\x02\x02\xec\x02*\n\r\n\x05\x04\t\x02\0\x05\ + \x12\x04\xee\x02\x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xee\x02\t\x1a\ + \n\r\n\x05\x04\t\x02\0\x03\x12\x04\xee\x02\x1d\x1e\n\xa2\x01\n\x02\x04\n\ + \x12\x06\xf3\x02\0\xfb\x02\x01\x1a\x93\x01\x20Request\x20message\x20for\ + \n\x20[google.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency][goo\ + gle.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency]\n\n\x0b\n\x03\ + \x04\n\x01\x12\x04\xf3\x02\x08\x1f\n\xac\x01\n\x04\x04\n\x02\0\x12\x04\ + \xf7\x02\x02\x12\x1a\x9d\x01\x20The\x20unique\x20name\x20of\x20the\x20Ta\ + ble\x20for\x20which\x20to\x20check\x20replication\x20consistency.\n\x20V\ + alues\x20are\x20of\x20the\x20form\n\x20`projects//instances//tables/
`.\n\n\x0f\n\x05\x04\n\x02\0\x04\x12\x06\xf7\x02\ + \x02\xf3\x02!\n\r\n\x05\x04\n\x02\0\x05\x12\x04\xf7\x02\x02\x08\n\r\n\ + \x05\x04\n\x02\0\x01\x12\x04\xf7\x02\t\r\n\r\n\x05\x04\n\x02\0\x03\x12\ + \x04\xf7\x02\x10\x11\nO\n\x04\x04\n\x02\x01\x12\x04\xfa\x02\x02\x1f\x1aA\ + \x20The\x20token\x20created\x20using\x20GenerateConsistencyToken\x20for\ + \x20the\x20Table.\n\n\x0f\n\x05\x04\n\x02\x01\x04\x12\x06\xfa\x02\x02\ + \xf7\x02\x12\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\xfa\x02\x02\x08\n\r\n\ + \x05\x04\n\x02\x01\x01\x12\x04\xfa\x02\t\x1a\n\r\n\x05\x04\n\x02\x01\x03\ + \x12\x04\xfa\x02\x1d\x1e\n\xa3\x01\n\x02\x04\x0b\x12\x06\xff\x02\0\x83\ + \x03\x01\x1a\x94\x01\x20Response\x20message\x20for\n\x20[google.bigtable\ + .admin.v2.BigtableTableAdmin.CheckConsistency][google.bigtable.admin.v2.\ + BigtableTableAdmin.CheckConsistency]\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\ + \xff\x02\x08\x20\n\x9a\x01\n\x04\x04\x0b\x02\0\x12\x04\x82\x03\x02\x16\ + \x1a\x8b\x01\x20True\x20only\x20if\x20the\x20token\x20is\x20consistent.\ + \x20A\x20token\x20is\x20consistent\x20if\x20replication\n\x20has\x20caug\ + ht\x20up\x20with\x20the\x20restrictions\x20specified\x20in\x20the\x20req\ + uest.\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\x82\x03\x02\xff\x02\"\n\r\ + \n\x05\x04\x0b\x02\0\x05\x12\x04\x82\x03\x02\x06\n\r\n\x05\x04\x0b\x02\0\ + \x01\x12\x04\x82\x03\x07\x11\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\x82\x03\ + \x14\x15\n\xc9\x03\n\x02\x04\x0c\x12\x06\x8c\x03\0\xa5\x03\x01\x1a\xba\ + \x03\x20Request\x20message\x20for\n\x20[google.bigtable.admin.v2.Bigtabl\ + eTableAdmin.SnapshotTable][google.bigtable.admin.v2.BigtableTableAdmin.S\ + napshotTable]\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20rel\ + ease\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\ + \x20not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20\ + customers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backw\ + ard-incompatible\x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20\ + production\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20\ + or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0c\x01\x12\x04\x8c\x03\ + \x08\x1c\n\x9c\x01\n\x04\x04\x0c\x02\0\x12\x04\x90\x03\x02\x12\x1a\x8d\ + \x01\x20The\x20unique\x20name\x20of\x20the\x20table\x20to\x20have\x20the\ + \x20snapshot\x20taken.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`pro\ + jects//instances//tables/
`.\n\n\x0f\n\x05\x04\ + \x0c\x02\0\x04\x12\x06\x90\x03\x02\x8c\x03\x1e\n\r\n\x05\x04\x0c\x02\0\ + \x05\x12\x04\x90\x03\x02\x08\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x90\x03\ + \t\r\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x90\x03\x10\x11\n\xa6\x01\n\x04\ + \x04\x0c\x02\x01\x12\x04\x95\x03\x02\x15\x1a\x97\x01\x20The\x20name\x20o\ + f\x20the\x20cluster\x20where\x20the\x20snapshot\x20will\x20be\x20created\ + \x20in.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects/\ + /instances//clusters/`.\n\n\x0f\n\x05\x04\x0c\x02\x01\ + \x04\x12\x06\x95\x03\x02\x90\x03\x12\n\r\n\x05\x04\x0c\x02\x01\x05\x12\ + \x04\x95\x03\x02\x08\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\x95\x03\t\x10\ + \n\r\n\x05\x04\x0c\x02\x01\x03\x12\x04\x95\x03\x13\x14\n\x82\x02\n\x04\ + \x04\x0c\x02\x02\x12\x04\x9b\x03\x02\x19\x1a\xf3\x01\x20The\x20ID\x20by\ + \x20which\x20the\x20new\x20snapshot\x20should\x20be\x20referred\x20to\ + \x20within\x20the\x20parent\n\x20cluster,\x20e.g.,\x20`mysnapshot`\x20of\ + \x20the\x20form:\x20`[_a-zA-Z0-9][-_.a-zA-Z0-9]*`\n\x20rather\x20than\n\ + \x20`projects//instances//clusters//snapshot\ + s/mysnapshot`.\n\n\x0f\n\x05\x04\x0c\x02\x02\x04\x12\x06\x9b\x03\x02\x95\ + \x03\x15\n\r\n\x05\x04\x0c\x02\x02\x05\x12\x04\x9b\x03\x02\x08\n\r\n\x05\ + \x04\x0c\x02\x02\x01\x12\x04\x9b\x03\t\x14\n\r\n\x05\x04\x0c\x02\x02\x03\ + \x12\x04\x9b\x03\x17\x18\n\x9c\x02\n\x04\x04\x0c\x02\x03\x12\x04\xa1\x03\ + \x02#\x1a\x8d\x02\x20The\x20amount\x20of\x20time\x20that\x20the\x20new\ + \x20snapshot\x20can\x20stay\x20active\x20after\x20it\x20is\n\x20created.\ + \x20Once\x20'ttl'\x20expires,\x20the\x20snapshot\x20will\x20get\x20delet\ + ed.\x20The\x20maximum\n\x20amount\x20of\x20time\x20a\x20snapshot\x20can\ + \x20stay\x20active\x20is\x207\x20days.\x20If\x20'ttl'\x20is\x20not\n\x20\ + specified,\x20the\x20default\x20value\x20of\x2024\x20hours\x20will\x20be\ + \x20used.\n\n\x0f\n\x05\x04\x0c\x02\x03\x04\x12\x06\xa1\x03\x02\x9b\x03\ + \x19\n\r\n\x05\x04\x0c\x02\x03\x06\x12\x04\xa1\x03\x02\x1a\n\r\n\x05\x04\ + \x0c\x02\x03\x01\x12\x04\xa1\x03\x1b\x1e\n\r\n\x05\x04\x0c\x02\x03\x03\ + \x12\x04\xa1\x03!\"\n,\n\x04\x04\x0c\x02\x04\x12\x04\xa4\x03\x02\x19\x1a\ + \x1e\x20Description\x20of\x20the\x20snapshot.\n\n\x0f\n\x05\x04\x0c\x02\ + \x04\x04\x12\x06\xa4\x03\x02\xa1\x03#\n\r\n\x05\x04\x0c\x02\x04\x05\x12\ + \x04\xa4\x03\x02\x08\n\r\n\x05\x04\x0c\x02\x04\x01\x12\x04\xa4\x03\t\x14\ + \n\r\n\x05\x04\x0c\x02\x04\x03\x12\x04\xa4\x03\x17\x18\n\xc5\x03\n\x02\ + \x04\r\x12\x06\xae\x03\0\xb3\x03\x01\x1a\xb6\x03\x20Request\x20message\ + \x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.GetSnapshot][g\ + oogle.bigtable.admin.v2.BigtableTableAdmin.GetSnapshot]\n\n\x20Note:\x20\ + This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtabl\ + e\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20availa\ + ble\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20featur\ + e\x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\x20an\ + d\x20is\x20not\x20recommended\n\x20for\x20production\x20use.\x20It\x20is\ + \x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\ + \n\x0b\n\x03\x04\r\x01\x12\x04\xae\x03\x08\x1a\n\xa7\x01\n\x04\x04\r\x02\ + \0\x12\x04\xb2\x03\x02\x12\x1a\x98\x01\x20The\x20unique\x20name\x20of\ + \x20the\x20requested\x20snapshot.\n\x20Values\x20are\x20of\x20the\x20for\ + m\n\x20`projects//instances//clusters//snaps\ + hots/`.\n\n\x0f\n\x05\x04\r\x02\0\x04\x12\x06\xb2\x03\x02\xae\ + \x03\x1c\n\r\n\x05\x04\r\x02\0\x05\x12\x04\xb2\x03\x02\x08\n\r\n\x05\x04\ + \r\x02\0\x01\x12\x04\xb2\x03\t\r\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xb2\ + \x03\x10\x11\n\xc9\x03\n\x02\x04\x0e\x12\x06\xbc\x03\0\xca\x03\x01\x1a\ + \xba\x03\x20Request\x20message\x20for\n\x20[google.bigtable.admin.v2.Big\ + tableTableAdmin.ListSnapshots][google.bigtable.admin.v2.BigtableTableAdm\ + in.ListSnapshots]\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\ + \x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20featur\ + e\x20is\x20not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigta\ + ble\x20customers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\ + \x20backward-incompatible\x20ways\x20and\x20is\x20not\x20recommended\n\ + \x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\ + \x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0e\x01\x12\ + \x04\xbc\x03\x08\x1c\n\xb3\x02\n\x04\x04\x0e\x02\0\x12\x04\xc2\x03\x02\ + \x14\x1a\xa4\x02\x20The\x20unique\x20name\x20of\x20the\x20cluster\x20for\ + \x20which\x20snapshots\x20should\x20be\x20listed.\n\x20Values\x20are\x20\ + of\x20the\x20form\n\x20`projects//instances//clusters\ + /`.\n\x20Use\x20`\x20=\x20'-'`\x20to\x20list\x20snapsh\ + ots\x20for\x20all\x20clusters\x20in\x20an\x20instance,\n\x20e.g.,\x20`pr\ + ojects//instances//clusters/-`.\n\n\x0f\n\x05\x04\x0e\ + \x02\0\x04\x12\x06\xc2\x03\x02\xbc\x03\x1e\n\r\n\x05\x04\x0e\x02\0\x05\ + \x12\x04\xc2\x03\x02\x08\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xc2\x03\t\ + \x0f\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xc2\x03\x12\x13\ni\n\x04\x04\ + \x0e\x02\x01\x12\x04\xc6\x03\x02\x16\x1a[\x20The\x20maximum\x20number\ + \x20of\x20snapshots\x20to\x20return\x20per\x20page.\n\x20CURRENTLY\x20UN\ + IMPLEMENTED\x20AND\x20IGNORED.\n\n\x0f\n\x05\x04\x0e\x02\x01\x04\x12\x06\ + \xc6\x03\x02\xc2\x03\x14\n\r\n\x05\x04\x0e\x02\x01\x05\x12\x04\xc6\x03\ + \x02\x07\n\r\n\x05\x04\x0e\x02\x01\x01\x12\x04\xc6\x03\x08\x11\n\r\n\x05\ + \x04\x0e\x02\x01\x03\x12\x04\xc6\x03\x14\x15\nK\n\x04\x04\x0e\x02\x02\ + \x12\x04\xc9\x03\x02\x18\x1a=\x20The\x20value\x20of\x20`next_page_token`\ + \x20returned\x20by\x20a\x20previous\x20call.\n\n\x0f\n\x05\x04\x0e\x02\ + \x02\x04\x12\x06\xc9\x03\x02\xc6\x03\x16\n\r\n\x05\x04\x0e\x02\x02\x05\ + \x12\x04\xc9\x03\x02\x08\n\r\n\x05\x04\x0e\x02\x02\x01\x12\x04\xc9\x03\t\ + \x13\n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\xc9\x03\x16\x17\n\xca\x03\n\ + \x02\x04\x0f\x12\x06\xd3\x03\0\xdb\x03\x01\x1a\xbb\x03\x20Response\x20me\ + ssage\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.ListSnaps\ + hots][google.bigtable.admin.v2.BigtableTableAdmin.ListSnapshots]\n\n\x20\ + Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\ + \x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currentl\ + y\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\ + \n\x20feature\x20might\x20be\x20changed\x20in\x20backward-incompatible\ + \x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20production\x20us\ + e.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecatio\ + n\x20policy.\n\n\x0b\n\x03\x04\x0f\x01\x12\x04\xd3\x03\x08\x1d\n?\n\x04\ + \x04\x0f\x02\0\x12\x04\xd5\x03\x02\"\x1a1\x20The\x20snapshots\x20present\ + \x20in\x20the\x20requested\x20cluster.\n\n\r\n\x05\x04\x0f\x02\0\x04\x12\ + \x04\xd5\x03\x02\n\n\r\n\x05\x04\x0f\x02\0\x06\x12\x04\xd5\x03\x0b\x13\n\ + \r\n\x05\x04\x0f\x02\0\x01\x12\x04\xd5\x03\x14\x1d\n\r\n\x05\x04\x0f\x02\ + \0\x03\x12\x04\xd5\x03\x20!\n\xa7\x01\n\x04\x04\x0f\x02\x01\x12\x04\xda\ + \x03\x02\x1d\x1a\x98\x01\x20Set\x20if\x20not\x20all\x20snapshots\x20coul\ + d\x20be\x20returned\x20in\x20a\x20single\x20response.\n\x20Pass\x20this\ + \x20value\x20to\x20`page_token`\x20in\x20another\x20request\x20to\x20get\ + \x20the\x20next\n\x20page\x20of\x20results.\n\n\x0f\n\x05\x04\x0f\x02\ + \x01\x04\x12\x06\xda\x03\x02\xd5\x03\"\n\r\n\x05\x04\x0f\x02\x01\x05\x12\ + \x04\xda\x03\x02\x08\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\xda\x03\t\x18\ + \n\r\n\x05\x04\x0f\x02\x01\x03\x12\x04\xda\x03\x1b\x1c\n\xcb\x03\n\x02\ + \x04\x10\x12\x06\xe4\x03\0\xe9\x03\x01\x1a\xbc\x03\x20Request\x20message\ + \x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.DeleteSnapshot\ + ][google.bigtable.admin.v2.BigtableTableAdmin.DeleteSnapshot]\n\n\x20Not\ + e:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20B\ + igtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20\ + available\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20\ + feature\x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\ + \x20and\x20is\x20not\x20recommended\n\x20for\x20production\x20use.\x20It\ + \x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20pol\ + icy.\n\n\x0b\n\x03\x04\x10\x01\x12\x04\xe4\x03\x08\x1d\n\xab\x01\n\x04\ + \x04\x10\x02\0\x12\x04\xe8\x03\x02\x12\x1a\x9c\x01\x20The\x20unique\x20n\ + ame\x20of\x20the\x20snapshot\x20to\x20be\x20deleted.\n\x20Values\x20are\ + \x20of\x20the\x20form\n\x20`projects//instances//clus\ + ters//snapshots/`.\n\n\x0f\n\x05\x04\x10\x02\0\x04\ + \x12\x06\xe8\x03\x02\xe4\x03\x1f\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\xe8\ + \x03\x02\x08\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\xe8\x03\t\r\n\r\n\x05\ + \x04\x10\x02\0\x03\x12\x04\xe8\x03\x10\x11\n\xf7\x02\n\x02\x04\x11\x12\ + \x06\xf1\x03\0\xfa\x03\x01\x1a\xe8\x02\x20The\x20metadata\x20for\x20the\ + \x20Operation\x20returned\x20by\x20SnapshotTable.\n\n\x20Note:\x20This\ + \x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\ + \x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20availab\ + le\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\ + \x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\x20and\ + \x20is\x20not\x20recommended\n\x20for\x20production\x20use.\x20It\x20is\ + \x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\ + \n\x0b\n\x03\x04\x11\x01\x12\x04\xf1\x03\x08\x1d\nY\n\x04\x04\x11\x02\0\ + \x12\x04\xf3\x03\x02,\x1aK\x20The\x20request\x20that\x20prompted\x20the\ + \x20initiation\x20of\x20this\x20SnapshotTable\x20operation.\n\n\x0f\n\ + \x05\x04\x11\x02\0\x04\x12\x06\xf3\x03\x02\xf1\x03\x1f\n\r\n\x05\x04\x11\ + \x02\0\x06\x12\x04\xf3\x03\x02\x16\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\ + \xf3\x03\x17'\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\xf3\x03*+\nD\n\x04\x04\ + \x11\x02\x01\x12\x04\xf6\x03\x02-\x1a6\x20The\x20time\x20at\x20which\x20\ + the\x20original\x20request\x20was\x20received.\n\n\x0f\n\x05\x04\x11\x02\ + \x01\x04\x12\x06\xf6\x03\x02\xf3\x03,\n\r\n\x05\x04\x11\x02\x01\x06\x12\ + \x04\xf6\x03\x02\x1b\n\r\n\x05\x04\x11\x02\x01\x01\x12\x04\xf6\x03\x1c(\ + \n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xf6\x03+,\nU\n\x04\x04\x11\x02\ + \x02\x12\x04\xf9\x03\x02,\x1aG\x20The\x20time\x20at\x20which\x20the\x20o\ + peration\x20failed\x20or\x20was\x20completed\x20successfully.\n\n\x0f\n\ + \x05\x04\x11\x02\x02\x04\x12\x06\xf9\x03\x02\xf6\x03-\n\r\n\x05\x04\x11\ + \x02\x02\x06\x12\x04\xf9\x03\x02\x1b\n\r\n\x05\x04\x11\x02\x02\x01\x12\ + \x04\xf9\x03\x1c'\n\r\n\x05\x04\x11\x02\x02\x03\x12\x04\xf9\x03*+\n\x81\ + \x03\n\x02\x04\x12\x12\x06\x82\x04\0\x8c\x04\x01\x1a\xf2\x02\x20The\x20m\ + etadata\x20for\x20the\x20Operation\x20returned\x20by\x20CreateTableFromS\ + napshot.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\ + \x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20\ + not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20cust\ + omers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-\ + incompatible\x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20prod\ + uction\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\ + \x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\x82\x04\x08\ + '\nd\n\x04\x04\x12\x02\0\x12\x04\x85\x04\x026\x1aV\x20The\x20request\x20\ + that\x20prompted\x20the\x20initiation\x20of\x20this\x20CreateTableFromSn\ + apshot\n\x20operation.\n\n\x0f\n\x05\x04\x12\x02\0\x04\x12\x06\x85\x04\ + \x02\x82\x04)\n\r\n\x05\x04\x12\x02\0\x06\x12\x04\x85\x04\x02\x20\n\r\n\ + \x05\x04\x12\x02\0\x01\x12\x04\x85\x04!1\n\r\n\x05\x04\x12\x02\0\x03\x12\ + \x04\x85\x0445\nD\n\x04\x04\x12\x02\x01\x12\x04\x88\x04\x02-\x1a6\x20The\ + \x20time\x20at\x20which\x20the\x20original\x20request\x20was\x20received\ + .\n\n\x0f\n\x05\x04\x12\x02\x01\x04\x12\x06\x88\x04\x02\x85\x046\n\r\n\ + \x05\x04\x12\x02\x01\x06\x12\x04\x88\x04\x02\x1b\n\r\n\x05\x04\x12\x02\ + \x01\x01\x12\x04\x88\x04\x1c(\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\x88\ + \x04+,\nU\n\x04\x04\x12\x02\x02\x12\x04\x8b\x04\x02,\x1aG\x20The\x20time\ + \x20at\x20which\x20the\x20operation\x20failed\x20or\x20was\x20completed\ + \x20successfully.\n\n\x0f\n\x05\x04\x12\x02\x02\x04\x12\x06\x8b\x04\x02\ + \x88\x04-\n\r\n\x05\x04\x12\x02\x02\x06\x12\x04\x8b\x04\x02\x1b\n\r\n\ + \x05\x04\x12\x02\x02\x01\x12\x04\x8b\x04\x1c'\n\r\n\x05\x04\x12\x02\x02\ + \x03\x12\x04\x8b\x04*+b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin_grpc.rs new file mode 100644 index 00000000..eb7e660b --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/bigtable_table_admin_grpc.rs @@ -0,0 +1,407 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/CreateTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE_FROM_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/CreateTableFromSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_LIST_TABLES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/ListTables", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_GET_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/GetTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_DELETE_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/DeleteTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_MODIFY_COLUMN_FAMILIES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/ModifyColumnFamilies", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_DROP_ROW_RANGE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/DropRowRange", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_GENERATE_CONSISTENCY_TOKEN: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/GenerateConsistencyToken", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_CHECK_CONSISTENCY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/CheckConsistency", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_SNAPSHOT_TABLE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/SnapshotTable", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_GET_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/GetSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_LIST_SNAPSHOTS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/ListSnapshots", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_TABLE_ADMIN_DELETE_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.admin.v2.BigtableTableAdmin/DeleteSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableTableAdminClient { + client: ::grpcio::Client, +} + +impl BigtableTableAdminClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableTableAdminClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_table_opt(&self, req: &super::bigtable_table_admin::CreateTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE, req, opt) + } + + pub fn create_table(&self, req: &super::bigtable_table_admin::CreateTableRequest) -> ::grpcio::Result { + self.create_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_table_async_opt(&self, req: &super::bigtable_table_admin::CreateTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE, req, opt) + } + + pub fn create_table_async(&self, req: &super::bigtable_table_admin::CreateTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_table_from_snapshot_opt(&self, req: &super::bigtable_table_admin::CreateTableFromSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE_FROM_SNAPSHOT, req, opt) + } + + pub fn create_table_from_snapshot(&self, req: &super::bigtable_table_admin::CreateTableFromSnapshotRequest) -> ::grpcio::Result { + self.create_table_from_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_table_from_snapshot_async_opt(&self, req: &super::bigtable_table_admin::CreateTableFromSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE_FROM_SNAPSHOT, req, opt) + } + + pub fn create_table_from_snapshot_async(&self, req: &super::bigtable_table_admin::CreateTableFromSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_table_from_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_tables_opt(&self, req: &super::bigtable_table_admin::ListTablesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_TABLES, req, opt) + } + + pub fn list_tables(&self, req: &super::bigtable_table_admin::ListTablesRequest) -> ::grpcio::Result { + self.list_tables_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_tables_async_opt(&self, req: &super::bigtable_table_admin::ListTablesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_TABLES, req, opt) + } + + pub fn list_tables_async(&self, req: &super::bigtable_table_admin::ListTablesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_tables_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_table_opt(&self, req: &super::bigtable_table_admin::GetTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_GET_TABLE, req, opt) + } + + pub fn get_table(&self, req: &super::bigtable_table_admin::GetTableRequest) -> ::grpcio::Result { + self.get_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_table_async_opt(&self, req: &super::bigtable_table_admin::GetTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_GET_TABLE, req, opt) + } + + pub fn get_table_async(&self, req: &super::bigtable_table_admin::GetTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_table_opt(&self, req: &super::bigtable_table_admin::DeleteTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_TABLE, req, opt) + } + + pub fn delete_table(&self, req: &super::bigtable_table_admin::DeleteTableRequest) -> ::grpcio::Result { + self.delete_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_table_async_opt(&self, req: &super::bigtable_table_admin::DeleteTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_TABLE, req, opt) + } + + pub fn delete_table_async(&self, req: &super::bigtable_table_admin::DeleteTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_column_families_opt(&self, req: &super::bigtable_table_admin::ModifyColumnFamiliesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_MODIFY_COLUMN_FAMILIES, req, opt) + } + + pub fn modify_column_families(&self, req: &super::bigtable_table_admin::ModifyColumnFamiliesRequest) -> ::grpcio::Result { + self.modify_column_families_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_column_families_async_opt(&self, req: &super::bigtable_table_admin::ModifyColumnFamiliesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_MODIFY_COLUMN_FAMILIES, req, opt) + } + + pub fn modify_column_families_async(&self, req: &super::bigtable_table_admin::ModifyColumnFamiliesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.modify_column_families_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn drop_row_range_opt(&self, req: &super::bigtable_table_admin::DropRowRangeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_DROP_ROW_RANGE, req, opt) + } + + pub fn drop_row_range(&self, req: &super::bigtable_table_admin::DropRowRangeRequest) -> ::grpcio::Result { + self.drop_row_range_opt(req, ::grpcio::CallOption::default()) + } + + pub fn drop_row_range_async_opt(&self, req: &super::bigtable_table_admin::DropRowRangeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_DROP_ROW_RANGE, req, opt) + } + + pub fn drop_row_range_async(&self, req: &super::bigtable_table_admin::DropRowRangeRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.drop_row_range_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn generate_consistency_token_opt(&self, req: &super::bigtable_table_admin::GenerateConsistencyTokenRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_GENERATE_CONSISTENCY_TOKEN, req, opt) + } + + pub fn generate_consistency_token(&self, req: &super::bigtable_table_admin::GenerateConsistencyTokenRequest) -> ::grpcio::Result { + self.generate_consistency_token_opt(req, ::grpcio::CallOption::default()) + } + + pub fn generate_consistency_token_async_opt(&self, req: &super::bigtable_table_admin::GenerateConsistencyTokenRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_GENERATE_CONSISTENCY_TOKEN, req, opt) + } + + pub fn generate_consistency_token_async(&self, req: &super::bigtable_table_admin::GenerateConsistencyTokenRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.generate_consistency_token_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_consistency_opt(&self, req: &super::bigtable_table_admin::CheckConsistencyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_CHECK_CONSISTENCY, req, opt) + } + + pub fn check_consistency(&self, req: &super::bigtable_table_admin::CheckConsistencyRequest) -> ::grpcio::Result { + self.check_consistency_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_consistency_async_opt(&self, req: &super::bigtable_table_admin::CheckConsistencyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_CHECK_CONSISTENCY, req, opt) + } + + pub fn check_consistency_async(&self, req: &super::bigtable_table_admin::CheckConsistencyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.check_consistency_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn snapshot_table_opt(&self, req: &super::bigtable_table_admin::SnapshotTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_SNAPSHOT_TABLE, req, opt) + } + + pub fn snapshot_table(&self, req: &super::bigtable_table_admin::SnapshotTableRequest) -> ::grpcio::Result { + self.snapshot_table_opt(req, ::grpcio::CallOption::default()) + } + + pub fn snapshot_table_async_opt(&self, req: &super::bigtable_table_admin::SnapshotTableRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_SNAPSHOT_TABLE, req, opt) + } + + pub fn snapshot_table_async(&self, req: &super::bigtable_table_admin::SnapshotTableRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.snapshot_table_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_snapshot_opt(&self, req: &super::bigtable_table_admin::GetSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_GET_SNAPSHOT, req, opt) + } + + pub fn get_snapshot(&self, req: &super::bigtable_table_admin::GetSnapshotRequest) -> ::grpcio::Result { + self.get_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_snapshot_async_opt(&self, req: &super::bigtable_table_admin::GetSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_GET_SNAPSHOT, req, opt) + } + + pub fn get_snapshot_async(&self, req: &super::bigtable_table_admin::GetSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_snapshots_opt(&self, req: &super::bigtable_table_admin::ListSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_SNAPSHOTS, req, opt) + } + + pub fn list_snapshots(&self, req: &super::bigtable_table_admin::ListSnapshotsRequest) -> ::grpcio::Result { + self.list_snapshots_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_snapshots_async_opt(&self, req: &super::bigtable_table_admin::ListSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_SNAPSHOTS, req, opt) + } + + pub fn list_snapshots_async(&self, req: &super::bigtable_table_admin::ListSnapshotsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_snapshots_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_snapshot_opt(&self, req: &super::bigtable_table_admin::DeleteSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_SNAPSHOT, req, opt) + } + + pub fn delete_snapshot(&self, req: &super::bigtable_table_admin::DeleteSnapshotRequest) -> ::grpcio::Result { + self.delete_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_snapshot_async_opt(&self, req: &super::bigtable_table_admin::DeleteSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_SNAPSHOT, req, opt) + } + + pub fn delete_snapshot_async(&self, req: &super::bigtable_table_admin::DeleteSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait BigtableTableAdmin { + fn create_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::CreateTableRequest, sink: ::grpcio::UnarySink); + fn create_table_from_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::CreateTableFromSnapshotRequest, sink: ::grpcio::UnarySink); + fn list_tables(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::ListTablesRequest, sink: ::grpcio::UnarySink); + fn get_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::GetTableRequest, sink: ::grpcio::UnarySink); + fn delete_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::DeleteTableRequest, sink: ::grpcio::UnarySink); + fn modify_column_families(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::ModifyColumnFamiliesRequest, sink: ::grpcio::UnarySink); + fn drop_row_range(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::DropRowRangeRequest, sink: ::grpcio::UnarySink); + fn generate_consistency_token(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::GenerateConsistencyTokenRequest, sink: ::grpcio::UnarySink); + fn check_consistency(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::CheckConsistencyRequest, sink: ::grpcio::UnarySink); + fn snapshot_table(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::SnapshotTableRequest, sink: ::grpcio::UnarySink); + fn get_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::GetSnapshotRequest, sink: ::grpcio::UnarySink); + fn list_snapshots(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::ListSnapshotsRequest, sink: ::grpcio::UnarySink); + fn delete_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_table_admin::DeleteSnapshotRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable_table_admin(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE, move |ctx, req, resp| { + instance.create_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_CREATE_TABLE_FROM_SNAPSHOT, move |ctx, req, resp| { + instance.create_table_from_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_TABLES, move |ctx, req, resp| { + instance.list_tables(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_GET_TABLE, move |ctx, req, resp| { + instance.get_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_TABLE, move |ctx, req, resp| { + instance.delete_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_MODIFY_COLUMN_FAMILIES, move |ctx, req, resp| { + instance.modify_column_families(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_DROP_ROW_RANGE, move |ctx, req, resp| { + instance.drop_row_range(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_GENERATE_CONSISTENCY_TOKEN, move |ctx, req, resp| { + instance.generate_consistency_token(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_CHECK_CONSISTENCY, move |ctx, req, resp| { + instance.check_consistency(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_SNAPSHOT_TABLE, move |ctx, req, resp| { + instance.snapshot_table(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_GET_SNAPSHOT, move |ctx, req, resp| { + instance.get_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_LIST_SNAPSHOTS, move |ctx, req, resp| { + instance.list_snapshots(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_TABLE_ADMIN_DELETE_SNAPSHOT, move |ctx, req, resp| { + instance.delete_snapshot(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/common.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/common.rs new file mode 100644 index 00000000..d2942ece --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/common.rs @@ -0,0 +1,142 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/v2/common.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum StorageType { + STORAGE_TYPE_UNSPECIFIED = 0, + SSD = 1, + HDD = 2, +} + +impl ::protobuf::ProtobufEnum for StorageType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(StorageType::STORAGE_TYPE_UNSPECIFIED), + 1 => ::std::option::Option::Some(StorageType::SSD), + 2 => ::std::option::Option::Some(StorageType::HDD), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [StorageType] = &[ + StorageType::STORAGE_TYPE_UNSPECIFIED, + StorageType::SSD, + StorageType::HDD, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("StorageType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for StorageType { +} + +impl ::std::default::Default for StorageType { + fn default() -> Self { + StorageType::STORAGE_TYPE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for StorageType { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n%google/bigtable/admin/v2/common.proto\x12\x18google.bigtable.admin.v2\ + \x1a\x1cgoogle/api/annotations.proto\x1a\x1fgoogle/protobuf/timestamp.pr\ + oto*=\n\x0bStorageType\x12\x1c\n\x18STORAGE_TYPE_UNSPECIFIED\x10\0\x12\ + \x07\n\x03SSD\x10\x01\x12\x07\n\x03HDD\x10\x02B\xae\x01\n\x1ccom.google.\ + bigtable.admin.v2B\x0bCommonProtoP\x01Z=google.golang.org/genproto/googl\ + eapis/bigtable/admin/v2;admin\xaa\x02\x1eGoogle.Cloud.Bigtable.Admin.V2\ + \xca\x02\x1eGoogle\\Cloud\\Bigtable\\Admin\\V2J\xb2\x08\n\x06\x12\x04\ + \x0f\0(\x01\n\xbe\x04\n\x01\x0c\x12\x03\x0f\0\x122\xb3\x04\x20Copyright\ + \x202018\x20Google\x20LLC.\n\n\x20Licensed\x20under\x20the\x20Apache\x20\ + License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20n\ + ot\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\ + \x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20Lice\ + nse\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-\ + 2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\ + \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\ + \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\ + \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\ + ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\ + the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\ + tations\x20under\x20the\x20License.\n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\ + \t\n\x02\x03\0\x12\x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\x14\0)\n\x08\n\ + \x01\x08\x12\x03\x16\0;\n\t\n\x02\x08%\x12\x03\x16\0;\n\x08\n\x01\x08\ + \x12\x03\x17\0T\n\t\n\x02\x08\x0b\x12\x03\x17\0T\n\x08\n\x01\x08\x12\x03\ + \x18\0\"\n\t\n\x02\x08\n\x12\x03\x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0,\ + \n\t\n\x02\x08\x08\x12\x03\x19\0,\n\x08\n\x01\x08\x12\x03\x1a\05\n\t\n\ + \x02\x08\x01\x12\x03\x1a\05\n\x08\n\x01\x08\x12\x03\x1b\0<\n\t\n\x02\x08\ + )\x12\x03\x1b\0<\n?\n\x02\x05\0\x12\x04\x1f\0(\x01\x1a3\x20Storage\x20me\ + dia\x20types\x20for\x20persisting\x20Bigtable\x20data.\n\n\n\n\x03\x05\0\ + \x01\x12\x03\x1f\x05\x10\n7\n\x04\x05\0\x02\0\x12\x03!\x02\x1f\x1a*\x20T\ + he\x20user\x20did\x20not\x20specify\x20a\x20storage\x20type.\n\n\x0c\n\ + \x05\x05\0\x02\0\x01\x12\x03!\x02\x1a\n\x0c\n\x05\x05\0\x02\0\x02\x12\ + \x03!\x1d\x1e\n2\n\x04\x05\0\x02\x01\x12\x03$\x02\n\x1a%\x20Flash\x20(SS\ + D)\x20storage\x20should\x20be\x20used.\n\n\x0c\n\x05\x05\0\x02\x01\x01\ + \x12\x03$\x02\x05\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03$\x08\t\n;\n\x04\ + \x05\0\x02\x02\x12\x03'\x02\n\x1a.\x20Magnetic\x20drive\x20(HDD)\x20stor\ + age\x20should\x20be\x20used.\n\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03'\ + \x02\x05\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03'\x08\tb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/instance.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/instance.rs new file mode 100644 index 00000000..779a252e --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/instance.rs @@ -0,0 +1,1862 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/v2/instance.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Instance { + // message fields + pub name: ::std::string::String, + pub display_name: ::std::string::String, + pub state: Instance_State, + pub field_type: Instance_Type, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Instance { + fn default() -> &'a Instance { + ::default_instance() + } +} + +impl Instance { + pub fn new() -> Instance { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string display_name = 2; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Instance.State state = 3; + + + pub fn get_state(&self) -> Instance_State { + self.state + } + pub fn clear_state(&mut self) { + self.state = Instance_State::STATE_NOT_KNOWN; + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: Instance_State) { + self.state = v; + } + + // .google.bigtable.admin.v2.Instance.Type type = 4; + + + pub fn get_field_type(&self) -> Instance_Type { + self.field_type + } + pub fn clear_field_type(&mut self) { + self.field_type = Instance_Type::TYPE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_field_type(&mut self, v: Instance_Type) { + self.field_type = v; + } + + // repeated .google.bigtable.admin.v2.Instance.LabelsEntry labels = 5; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for Instance { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + 3 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 3, &mut self.unknown_fields)? + }, + 4 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 4, &mut self.unknown_fields)? + }, + 5 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.display_name); + } + if self.state != Instance_State::STATE_NOT_KNOWN { + my_size += ::protobuf::rt::enum_size(3, self.state); + } + if self.field_type != Instance_Type::TYPE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(4, self.field_type); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.labels); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.display_name.is_empty() { + os.write_string(2, &self.display_name)?; + } + if self.state != Instance_State::STATE_NOT_KNOWN { + os.write_enum(3, self.state.value())?; + } + if self.field_type != Instance_Type::TYPE_UNSPECIFIED { + os.write_enum(4, self.field_type.value())?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(5, &self.labels, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Instance { + Instance::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Instance| { &m.name }, + |m: &mut Instance| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &Instance| { &m.display_name }, + |m: &mut Instance| { &mut m.display_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "state", + |m: &Instance| { &m.state }, + |m: &mut Instance| { &mut m.state }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "type", + |m: &Instance| { &m.field_type }, + |m: &mut Instance| { &mut m.field_type }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Instance| { &m.labels }, + |m: &mut Instance| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Instance", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Instance { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Instance, + }; + unsafe { + instance.get(Instance::new) + } + } +} + +impl ::protobuf::Clear for Instance { + fn clear(&mut self) { + self.name.clear(); + self.display_name.clear(); + self.state = Instance_State::STATE_NOT_KNOWN; + self.field_type = Instance_Type::TYPE_UNSPECIFIED; + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Instance { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Instance { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Instance_State { + STATE_NOT_KNOWN = 0, + READY = 1, + CREATING = 2, +} + +impl ::protobuf::ProtobufEnum for Instance_State { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Instance_State::STATE_NOT_KNOWN), + 1 => ::std::option::Option::Some(Instance_State::READY), + 2 => ::std::option::Option::Some(Instance_State::CREATING), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Instance_State] = &[ + Instance_State::STATE_NOT_KNOWN, + Instance_State::READY, + Instance_State::CREATING, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Instance_State", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Instance_State { +} + +impl ::std::default::Default for Instance_State { + fn default() -> Self { + Instance_State::STATE_NOT_KNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Instance_State { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Instance_Type { + TYPE_UNSPECIFIED = 0, + PRODUCTION = 1, + DEVELOPMENT = 2, +} + +impl ::protobuf::ProtobufEnum for Instance_Type { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Instance_Type::TYPE_UNSPECIFIED), + 1 => ::std::option::Option::Some(Instance_Type::PRODUCTION), + 2 => ::std::option::Option::Some(Instance_Type::DEVELOPMENT), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Instance_Type] = &[ + Instance_Type::TYPE_UNSPECIFIED, + Instance_Type::PRODUCTION, + Instance_Type::DEVELOPMENT, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Instance_Type", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Instance_Type { +} + +impl ::std::default::Default for Instance_Type { + fn default() -> Self { + Instance_Type::TYPE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for Instance_Type { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Cluster { + // message fields + pub name: ::std::string::String, + pub location: ::std::string::String, + pub state: Cluster_State, + pub serve_nodes: i32, + pub default_storage_type: super::common::StorageType, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Cluster { + fn default() -> &'a Cluster { + ::default_instance() + } +} + +impl Cluster { + pub fn new() -> Cluster { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string location = 2; + + + pub fn get_location(&self) -> &str { + &self.location + } + pub fn clear_location(&mut self) { + self.location.clear(); + } + + // Param is passed by value, moved + pub fn set_location(&mut self, v: ::std::string::String) { + self.location = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_location(&mut self) -> &mut ::std::string::String { + &mut self.location + } + + // Take field + pub fn take_location(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.location, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Cluster.State state = 3; + + + pub fn get_state(&self) -> Cluster_State { + self.state + } + pub fn clear_state(&mut self) { + self.state = Cluster_State::STATE_NOT_KNOWN; + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: Cluster_State) { + self.state = v; + } + + // int32 serve_nodes = 4; + + + pub fn get_serve_nodes(&self) -> i32 { + self.serve_nodes + } + pub fn clear_serve_nodes(&mut self) { + self.serve_nodes = 0; + } + + // Param is passed by value, moved + pub fn set_serve_nodes(&mut self, v: i32) { + self.serve_nodes = v; + } + + // .google.bigtable.admin.v2.StorageType default_storage_type = 5; + + + pub fn get_default_storage_type(&self) -> super::common::StorageType { + self.default_storage_type + } + pub fn clear_default_storage_type(&mut self) { + self.default_storage_type = super::common::StorageType::STORAGE_TYPE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_default_storage_type(&mut self, v: super::common::StorageType) { + self.default_storage_type = v; + } +} + +impl ::protobuf::Message for Cluster { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.location)?; + }, + 3 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 3, &mut self.unknown_fields)? + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.serve_nodes = tmp; + }, + 5 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.default_storage_type, 5, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.location.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.location); + } + if self.state != Cluster_State::STATE_NOT_KNOWN { + my_size += ::protobuf::rt::enum_size(3, self.state); + } + if self.serve_nodes != 0 { + my_size += ::protobuf::rt::value_size(4, self.serve_nodes, ::protobuf::wire_format::WireTypeVarint); + } + if self.default_storage_type != super::common::StorageType::STORAGE_TYPE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(5, self.default_storage_type); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.location.is_empty() { + os.write_string(2, &self.location)?; + } + if self.state != Cluster_State::STATE_NOT_KNOWN { + os.write_enum(3, self.state.value())?; + } + if self.serve_nodes != 0 { + os.write_int32(4, self.serve_nodes)?; + } + if self.default_storage_type != super::common::StorageType::STORAGE_TYPE_UNSPECIFIED { + os.write_enum(5, self.default_storage_type.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Cluster { + Cluster::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Cluster| { &m.name }, + |m: &mut Cluster| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "location", + |m: &Cluster| { &m.location }, + |m: &mut Cluster| { &mut m.location }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "state", + |m: &Cluster| { &m.state }, + |m: &mut Cluster| { &mut m.state }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "serve_nodes", + |m: &Cluster| { &m.serve_nodes }, + |m: &mut Cluster| { &mut m.serve_nodes }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "default_storage_type", + |m: &Cluster| { &m.default_storage_type }, + |m: &mut Cluster| { &mut m.default_storage_type }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Cluster", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Cluster { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Cluster, + }; + unsafe { + instance.get(Cluster::new) + } + } +} + +impl ::protobuf::Clear for Cluster { + fn clear(&mut self) { + self.name.clear(); + self.location.clear(); + self.state = Cluster_State::STATE_NOT_KNOWN; + self.serve_nodes = 0; + self.default_storage_type = super::common::StorageType::STORAGE_TYPE_UNSPECIFIED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Cluster { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Cluster { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Cluster_State { + STATE_NOT_KNOWN = 0, + READY = 1, + CREATING = 2, + RESIZING = 3, + DISABLED = 4, +} + +impl ::protobuf::ProtobufEnum for Cluster_State { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Cluster_State::STATE_NOT_KNOWN), + 1 => ::std::option::Option::Some(Cluster_State::READY), + 2 => ::std::option::Option::Some(Cluster_State::CREATING), + 3 => ::std::option::Option::Some(Cluster_State::RESIZING), + 4 => ::std::option::Option::Some(Cluster_State::DISABLED), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Cluster_State] = &[ + Cluster_State::STATE_NOT_KNOWN, + Cluster_State::READY, + Cluster_State::CREATING, + Cluster_State::RESIZING, + Cluster_State::DISABLED, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Cluster_State", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Cluster_State { +} + +impl ::std::default::Default for Cluster_State { + fn default() -> Self { + Cluster_State::STATE_NOT_KNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Cluster_State { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct AppProfile { + // message fields + pub name: ::std::string::String, + pub etag: ::std::string::String, + pub description: ::std::string::String, + // message oneof groups + pub routing_policy: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a AppProfile { + fn default() -> &'a AppProfile { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum AppProfile_oneof_routing_policy { + multi_cluster_routing_use_any(AppProfile_MultiClusterRoutingUseAny), + single_cluster_routing(AppProfile_SingleClusterRouting), +} + +impl AppProfile { + pub fn new() -> AppProfile { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string etag = 2; + + + pub fn get_etag(&self) -> &str { + &self.etag + } + pub fn clear_etag(&mut self) { + self.etag.clear(); + } + + // Param is passed by value, moved + pub fn set_etag(&mut self, v: ::std::string::String) { + self.etag = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_etag(&mut self) -> &mut ::std::string::String { + &mut self.etag + } + + // Take field + pub fn take_etag(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.etag, ::std::string::String::new()) + } + + // string description = 3; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.AppProfile.MultiClusterRoutingUseAny multi_cluster_routing_use_any = 5; + + + pub fn get_multi_cluster_routing_use_any(&self) -> &AppProfile_MultiClusterRoutingUseAny { + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v)) => v, + _ => AppProfile_MultiClusterRoutingUseAny::default_instance(), + } + } + pub fn clear_multi_cluster_routing_use_any(&mut self) { + self.routing_policy = ::std::option::Option::None; + } + + pub fn has_multi_cluster_routing_use_any(&self) -> bool { + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_multi_cluster_routing_use_any(&mut self, v: AppProfile_MultiClusterRoutingUseAny) { + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(v)) + } + + // Mutable pointer to the field. + pub fn mut_multi_cluster_routing_use_any(&mut self) -> &mut AppProfile_MultiClusterRoutingUseAny { + if let ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(_)) = self.routing_policy { + } else { + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(AppProfile_MultiClusterRoutingUseAny::new())); + } + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_multi_cluster_routing_use_any(&mut self) -> AppProfile_MultiClusterRoutingUseAny { + if self.has_multi_cluster_routing_use_any() { + match self.routing_policy.take() { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(v)) => v, + _ => panic!(), + } + } else { + AppProfile_MultiClusterRoutingUseAny::new() + } + } + + // .google.bigtable.admin.v2.AppProfile.SingleClusterRouting single_cluster_routing = 6; + + + pub fn get_single_cluster_routing(&self) -> &AppProfile_SingleClusterRouting { + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref v)) => v, + _ => AppProfile_SingleClusterRouting::default_instance(), + } + } + pub fn clear_single_cluster_routing(&mut self) { + self.routing_policy = ::std::option::Option::None; + } + + pub fn has_single_cluster_routing(&self) -> bool { + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_single_cluster_routing(&mut self, v: AppProfile_SingleClusterRouting) { + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(v)) + } + + // Mutable pointer to the field. + pub fn mut_single_cluster_routing(&mut self) -> &mut AppProfile_SingleClusterRouting { + if let ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(_)) = self.routing_policy { + } else { + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(AppProfile_SingleClusterRouting::new())); + } + match self.routing_policy { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_single_cluster_routing(&mut self) -> AppProfile_SingleClusterRouting { + if self.has_single_cluster_routing() { + match self.routing_policy.take() { + ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(v)) => v, + _ => panic!(), + } + } else { + AppProfile_SingleClusterRouting::new() + } + } +} + +impl ::protobuf::Message for AppProfile { + fn is_initialized(&self) -> bool { + if let Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v)) = self.routing_policy { + if !v.is_initialized() { + return false; + } + } + if let Some(AppProfile_oneof_routing_policy::single_cluster_routing(ref v)) = self.routing_policy { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.etag)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(is.read_message()?)); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.routing_policy = ::std::option::Option::Some(AppProfile_oneof_routing_policy::single_cluster_routing(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.etag.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.etag); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.description); + } + if let ::std::option::Option::Some(ref v) = self.routing_policy { + match v { + &AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &AppProfile_oneof_routing_policy::single_cluster_routing(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.etag.is_empty() { + os.write_string(2, &self.etag)?; + } + if !self.description.is_empty() { + os.write_string(3, &self.description)?; + } + if let ::std::option::Option::Some(ref v) = self.routing_policy { + match v { + &AppProfile_oneof_routing_policy::multi_cluster_routing_use_any(ref v) => { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &AppProfile_oneof_routing_policy::single_cluster_routing(ref v) => { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> AppProfile { + AppProfile::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &AppProfile| { &m.name }, + |m: &mut AppProfile| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "etag", + |m: &AppProfile| { &m.etag }, + |m: &mut AppProfile| { &mut m.etag }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &AppProfile| { &m.description }, + |m: &mut AppProfile| { &mut m.description }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, AppProfile_MultiClusterRoutingUseAny>( + "multi_cluster_routing_use_any", + AppProfile::has_multi_cluster_routing_use_any, + AppProfile::get_multi_cluster_routing_use_any, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, AppProfile_SingleClusterRouting>( + "single_cluster_routing", + AppProfile::has_single_cluster_routing, + AppProfile::get_single_cluster_routing, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AppProfile", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static AppProfile { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AppProfile, + }; + unsafe { + instance.get(AppProfile::new) + } + } +} + +impl ::protobuf::Clear for AppProfile { + fn clear(&mut self) { + self.name.clear(); + self.etag.clear(); + self.description.clear(); + self.routing_policy = ::std::option::Option::None; + self.routing_policy = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for AppProfile { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for AppProfile { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct AppProfile_MultiClusterRoutingUseAny { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a AppProfile_MultiClusterRoutingUseAny { + fn default() -> &'a AppProfile_MultiClusterRoutingUseAny { + ::default_instance() + } +} + +impl AppProfile_MultiClusterRoutingUseAny { + pub fn new() -> AppProfile_MultiClusterRoutingUseAny { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for AppProfile_MultiClusterRoutingUseAny { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> AppProfile_MultiClusterRoutingUseAny { + AppProfile_MultiClusterRoutingUseAny::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "AppProfile_MultiClusterRoutingUseAny", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static AppProfile_MultiClusterRoutingUseAny { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AppProfile_MultiClusterRoutingUseAny, + }; + unsafe { + instance.get(AppProfile_MultiClusterRoutingUseAny::new) + } + } +} + +impl ::protobuf::Clear for AppProfile_MultiClusterRoutingUseAny { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for AppProfile_MultiClusterRoutingUseAny { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for AppProfile_MultiClusterRoutingUseAny { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct AppProfile_SingleClusterRouting { + // message fields + pub cluster_id: ::std::string::String, + pub allow_transactional_writes: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a AppProfile_SingleClusterRouting { + fn default() -> &'a AppProfile_SingleClusterRouting { + ::default_instance() + } +} + +impl AppProfile_SingleClusterRouting { + pub fn new() -> AppProfile_SingleClusterRouting { + ::std::default::Default::default() + } + + // string cluster_id = 1; + + + pub fn get_cluster_id(&self) -> &str { + &self.cluster_id + } + pub fn clear_cluster_id(&mut self) { + self.cluster_id.clear(); + } + + // Param is passed by value, moved + pub fn set_cluster_id(&mut self, v: ::std::string::String) { + self.cluster_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cluster_id(&mut self) -> &mut ::std::string::String { + &mut self.cluster_id + } + + // Take field + pub fn take_cluster_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.cluster_id, ::std::string::String::new()) + } + + // bool allow_transactional_writes = 2; + + + pub fn get_allow_transactional_writes(&self) -> bool { + self.allow_transactional_writes + } + pub fn clear_allow_transactional_writes(&mut self) { + self.allow_transactional_writes = false; + } + + // Param is passed by value, moved + pub fn set_allow_transactional_writes(&mut self, v: bool) { + self.allow_transactional_writes = v; + } +} + +impl ::protobuf::Message for AppProfile_SingleClusterRouting { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cluster_id)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.allow_transactional_writes = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.cluster_id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.cluster_id); + } + if self.allow_transactional_writes != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.cluster_id.is_empty() { + os.write_string(1, &self.cluster_id)?; + } + if self.allow_transactional_writes != false { + os.write_bool(2, self.allow_transactional_writes)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> AppProfile_SingleClusterRouting { + AppProfile_SingleClusterRouting::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "cluster_id", + |m: &AppProfile_SingleClusterRouting| { &m.cluster_id }, + |m: &mut AppProfile_SingleClusterRouting| { &mut m.cluster_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "allow_transactional_writes", + |m: &AppProfile_SingleClusterRouting| { &m.allow_transactional_writes }, + |m: &mut AppProfile_SingleClusterRouting| { &mut m.allow_transactional_writes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AppProfile_SingleClusterRouting", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static AppProfile_SingleClusterRouting { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AppProfile_SingleClusterRouting, + }; + unsafe { + instance.get(AppProfile_SingleClusterRouting::new) + } + } +} + +impl ::protobuf::Clear for AppProfile_SingleClusterRouting { + fn clear(&mut self) { + self.cluster_id.clear(); + self.allow_transactional_writes = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for AppProfile_SingleClusterRouting { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for AppProfile_SingleClusterRouting { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n'google/bigtable/admin/v2/instance.proto\x12\x18google.bigtable.admin.\ + v2\x1a\x1cgoogle/api/annotations.proto\x1a%google/bigtable/admin/v2/comm\ + on.proto\"\xb7\x03\n\x08Instance\x12\x12\n\x04name\x18\x01\x20\x01(\tR\ + \x04name\x12!\n\x0cdisplay_name\x18\x02\x20\x01(\tR\x0bdisplayName\x12>\ + \n\x05state\x18\x03\x20\x01(\x0e2(.google.bigtable.admin.v2.Instance.Sta\ + teR\x05state\x12;\n\x04type\x18\x04\x20\x01(\x0e2'.google.bigtable.admin\ + .v2.Instance.TypeR\x04type\x12F\n\x06labels\x18\x05\x20\x03(\x0b2..googl\ + e.bigtable.admin.v2.Instance.LabelsEntryR\x06labels\x1a9\n\x0bLabelsEntr\ + y\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\ + \x20\x01(\tR\x05value:\x028\x01\"5\n\x05State\x12\x13\n\x0fSTATE_NOT_KNO\ + WN\x10\0\x12\t\n\x05READY\x10\x01\x12\x0c\n\x08CREATING\x10\x02\"=\n\x04\ + Type\x12\x14\n\x10TYPE_UNSPECIFIED\x10\0\x12\x0e\n\nPRODUCTION\x10\x01\ + \x12\x0f\n\x0bDEVELOPMENT\x10\x02\"\xc5\x02\n\x07Cluster\x12\x12\n\x04na\ + me\x18\x01\x20\x01(\tR\x04name\x12\x1a\n\x08location\x18\x02\x20\x01(\tR\ + \x08location\x12=\n\x05state\x18\x03\x20\x01(\x0e2'.google.bigtable.admi\ + n.v2.Cluster.StateR\x05state\x12\x1f\n\x0bserve_nodes\x18\x04\x20\x01(\ + \x05R\nserveNodes\x12W\n\x14default_storage_type\x18\x05\x20\x01(\x0e2%.\ + google.bigtable.admin.v2.StorageTypeR\x12defaultStorageType\"Q\n\x05Stat\ + e\x12\x13\n\x0fSTATE_NOT_KNOWN\x10\0\x12\t\n\x05READY\x10\x01\x12\x0c\n\ + \x08CREATING\x10\x02\x12\x0c\n\x08RESIZING\x10\x03\x12\x0c\n\x08DISABLED\ + \x10\x04\"\xf2\x03\n\nAppProfile\x12\x12\n\x04name\x18\x01\x20\x01(\tR\ + \x04name\x12\x12\n\x04etag\x18\x02\x20\x01(\tR\x04etag\x12\x20\n\x0bdesc\ + ription\x18\x03\x20\x01(\tR\x0bdescription\x12\x82\x01\n\x1dmulti_cluste\ + r_routing_use_any\x18\x05\x20\x01(\x0b2>.google.bigtable.admin.v2.AppPro\ + file.MultiClusterRoutingUseAnyH\0R\x19multiClusterRoutingUseAny\x12q\n\ + \x16single_cluster_routing\x18\x06\x20\x01(\x0b29.google.bigtable.admin.\ + v2.AppProfile.SingleClusterRoutingH\0R\x14singleClusterRouting\x1a\x1b\n\ + \x19MultiClusterRoutingUseAny\x1as\n\x14SingleClusterRouting\x12\x1d\n\n\ + cluster_id\x18\x01\x20\x01(\tR\tclusterId\x12<\n\x1aallow_transactional_\ + writes\x18\x02\x20\x01(\x08R\x18allowTransactionalWritesB\x10\n\x0erouti\ + ng_policyB\xb0\x01\n\x1ccom.google.bigtable.admin.v2B\rInstanceProtoP\ + \x01Z=google.golang.org/genproto/googleapis/bigtable/admin/v2;admin\xaa\ + \x02\x1eGoogle.Cloud.Bigtable.Admin.V2\xca\x02\x1eGoogle\\Cloud\\Bigtabl\ + e\\Admin\\V2J\xc1A\n\x07\x12\x05\x0f\0\xcf\x01\x01\n\xbe\x04\n\x01\x0c\ + \x12\x03\x0f\0\x122\xb3\x04\x20Copyright\x202018\x20Google\x20LLC.\n\n\ + \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\ + (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\ + xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\ + obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\ + \x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\ + \x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\ + oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\ + \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\ + \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\ + ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\ + governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\ + nse.\n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\t\n\x02\x03\0\x12\x03\x13\0&\n\ + \t\n\x02\x03\x01\x12\x03\x14\0/\n\x08\n\x01\x08\x12\x03\x16\0;\n\t\n\x02\ + \x08%\x12\x03\x16\0;\n\x08\n\x01\x08\x12\x03\x17\0T\n\t\n\x02\x08\x0b\ + \x12\x03\x17\0T\n\x08\n\x01\x08\x12\x03\x18\0\"\n\t\n\x02\x08\n\x12\x03\ + \x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\x02\x08\x08\x12\x03\x19\0.\ + \n\x08\n\x01\x08\x12\x03\x1a\05\n\t\n\x02\x08\x01\x12\x03\x1a\05\n\x08\n\ + \x01\x08\x12\x03\x1b\0<\n\t\n\x02\x08)\x12\x03\x1b\0<\n\xd6\x01\n\x02\ + \x04\0\x12\x04\"\0c\x01\x1a\xc9\x01\x20A\x20collection\x20of\x20Bigtable\ + \x20[Tables][google.bigtable.admin.v2.Table]\x20and\n\x20the\x20resource\ + s\x20that\x20serve\x20them.\n\x20All\x20tables\x20in\x20an\x20instance\ + \x20are\x20served\x20from\x20a\x20single\n\x20[Cluster][google.bigtable.\ + admin.v2.Cluster].\n\n\n\n\x03\x04\0\x01\x12\x03\"\x08\x10\n/\n\x04\x04\ + \0\x04\0\x12\x04$\x02/\x03\x1a!\x20Possible\x20states\x20of\x20an\x20ins\ + tance.\n\n\x0c\n\x05\x04\0\x04\0\x01\x12\x03$\x07\x0c\nC\n\x06\x04\0\x04\ + \0\x02\0\x12\x03&\x04\x18\x1a4\x20The\x20state\x20of\x20the\x20instance\ + \x20could\x20not\x20be\x20determined.\n\n\x0e\n\x07\x04\0\x04\0\x02\0\ + \x01\x12\x03&\x04\x13\n\x0e\n\x07\x04\0\x04\0\x02\0\x02\x12\x03&\x16\x17\ + \nb\n\x06\x04\0\x04\0\x02\x01\x12\x03*\x04\x0e\x1aS\x20The\x20instance\ + \x20has\x20been\x20successfully\x20created\x20and\x20can\x20serve\x20req\ + uests\n\x20to\x20its\x20tables.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\ + \x12\x03*\x04\t\n\x0e\n\x07\x04\0\x04\0\x02\x01\x02\x12\x03*\x0c\r\n|\n\ + \x06\x04\0\x04\0\x02\x02\x12\x03.\x04\x11\x1am\x20The\x20instance\x20is\ + \x20currently\x20being\x20created,\x20and\x20may\x20be\x20destroyed\n\ + \x20if\x20the\x20creation\x20process\x20encounters\x20an\x20error.\n\n\ + \x0e\n\x07\x04\0\x04\0\x02\x02\x01\x12\x03.\x04\x0c\n\x0e\n\x07\x04\0\ + \x04\0\x02\x02\x02\x12\x03.\x0f\x10\n)\n\x04\x04\0\x04\x01\x12\x042\x02D\ + \x03\x1a\x1b\x20The\x20type\x20of\x20the\x20instance.\n\n\x0c\n\x05\x04\ + \0\x04\x01\x01\x12\x032\x07\x0b\n\xca\x01\n\x06\x04\0\x04\x01\x02\0\x12\ + \x036\x04\x19\x1a\xba\x01\x20The\x20type\x20of\x20the\x20instance\x20is\ + \x20unspecified.\x20If\x20set\x20when\x20creating\x20an\n\x20instance,\ + \x20a\x20`PRODUCTION`\x20instance\x20will\x20be\x20created.\x20If\x20set\ + \x20when\x20updating\n\x20an\x20instance,\x20the\x20type\x20will\x20be\ + \x20left\x20unchanged.\n\n\x0e\n\x07\x04\0\x04\x01\x02\0\x01\x12\x036\ + \x04\x14\n\x0e\n\x07\x04\0\x04\x01\x02\0\x02\x12\x036\x17\x18\na\n\x06\ + \x04\0\x04\x01\x02\x01\x12\x03:\x04\x13\x1aR\x20An\x20instance\x20meant\ + \x20for\x20production\x20use.\x20`serve_nodes`\x20must\x20be\x20set\n\ + \x20on\x20the\x20cluster.\n\n\x0e\n\x07\x04\0\x04\x01\x02\x01\x01\x12\ + \x03:\x04\x0e\n\x0e\n\x07\x04\0\x04\x01\x02\x01\x02\x12\x03:\x11\x12\n\ + \xb7\x03\n\x06\x04\0\x04\x01\x02\x02\x12\x03C\x04\x14\x1a\xa7\x03\x20The\ + \x20instance\x20is\x20meant\x20for\x20development\x20and\x20testing\x20p\ + urposes\x20only;\x20it\x20has\n\x20no\x20performance\x20or\x20uptime\x20\ + guarantees\x20and\x20is\x20not\x20covered\x20by\x20SLA.\n\x20After\x20a\ + \x20development\x20instance\x20is\x20created,\x20it\x20can\x20be\x20upgr\ + aded\x20by\n\x20updating\x20the\x20instance\x20to\x20type\x20`PRODUCTION\ + `.\x20An\x20instance\x20created\n\x20as\x20a\x20production\x20instance\ + \x20cannot\x20be\x20changed\x20to\x20a\x20development\x20instance.\n\x20\ + When\x20creating\x20a\x20development\x20instance,\x20`serve_nodes`\x20on\ + \x20the\x20cluster\x20must\n\x20not\x20be\x20set.\n\n\x0e\n\x07\x04\0\ + \x04\x01\x02\x02\x01\x12\x03C\x04\x0f\n\x0e\n\x07\x04\0\x04\x01\x02\x02\ + \x02\x12\x03C\x12\x13\n\x92\x01\n\x04\x04\0\x02\0\x12\x03I\x02\x12\x1a\ + \x84\x01\x20(`OutputOnly`)\n\x20The\x20unique\x20name\x20of\x20the\x20in\ + stance.\x20Values\x20are\x20of\x20the\x20form\n\x20`projects//i\ + nstances/[a-z][a-z0-9\\\\-]+[a-z0-9]`.\n\n\r\n\x05\x04\0\x02\0\x04\x12\ + \x04I\x02D\x03\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03I\x02\x08\n\x0c\n\x05\ + \x04\0\x02\0\x01\x12\x03I\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03I\x10\ + \x11\n\xa1\x01\n\x04\x04\0\x02\x01\x12\x03N\x02\x1a\x1a\x93\x01\x20The\ + \x20descriptive\x20name\x20for\x20this\x20instance\x20as\x20it\x20appear\ + s\x20in\x20UIs.\n\x20Can\x20be\x20changed\x20at\x20any\x20time,\x20but\ + \x20should\x20be\x20kept\x20globally\x20unique\n\x20to\x20avoid\x20confu\ + sion.\n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04N\x02I\x12\n\x0c\n\x05\x04\0\ + \x02\x01\x05\x12\x03N\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03N\t\ + \x15\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03N\x18\x19\nA\n\x04\x04\0\x02\ + \x02\x12\x03R\x02\x12\x1a4\x20(`OutputOnly`)\n\x20The\x20current\x20stat\ + e\x20of\x20the\x20instance.\n\n\r\n\x05\x04\0\x02\x02\x04\x12\x04R\x02N\ + \x1a\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03R\x02\x07\n\x0c\n\x05\x04\0\ + \x02\x02\x01\x12\x03R\x08\r\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03R\x10\ + \x11\nB\n\x04\x04\0\x02\x03\x12\x03U\x02\x10\x1a5\x20The\x20type\x20of\ + \x20the\x20instance.\x20Defaults\x20to\x20`PRODUCTION`.\n\n\r\n\x05\x04\ + \0\x02\x03\x04\x12\x04U\x02R\x12\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03U\ + \x02\x06\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03U\x07\x0b\n\x0c\n\x05\x04\ + \0\x02\x03\x03\x12\x03U\x0e\x0f\n\x82\x05\n\x04\x04\0\x02\x04\x12\x03b\ + \x02!\x1a\xf4\x04\x20Labels\x20are\x20a\x20flexible\x20and\x20lightweigh\ + t\x20mechanism\x20for\x20organizing\x20cloud\n\x20resources\x20into\x20g\ + roups\x20that\x20reflect\x20a\x20customer's\x20organizational\x20needs\ + \x20and\n\x20deployment\x20strategies.\x20They\x20can\x20be\x20used\x20t\ + o\x20filter\x20resources\x20and\x20aggregate\n\x20metrics.\n\n\x20*\x20L\ + abel\x20keys\x20must\x20be\x20between\x201\x20and\x2063\x20characters\ + \x20long\x20and\x20must\x20conform\x20to\n\x20\x20\x20the\x20regular\x20\ + expression:\x20`[\\p{Ll}\\p{Lo}][\\p{Ll}\\p{Lo}\\p{N}_-]{0,62}`.\n\x20*\ + \x20Label\x20values\x20must\x20be\x20between\x200\x20and\x2063\x20charac\ + ters\x20long\x20and\x20must\x20conform\x20to\n\x20\x20\x20the\x20regular\ + \x20expression:\x20`[\\p{Ll}\\p{Lo}\\p{N}_-]{0,63}`.\n\x20*\x20No\x20mor\ + e\x20than\x2064\x20labels\x20can\x20be\x20associated\x20with\x20a\x20giv\ + en\x20resource.\n\x20*\x20Keys\x20and\x20values\x20must\x20both\x20be\ + \x20under\x20128\x20bytes.\n\n\r\n\x05\x04\0\x02\x04\x04\x12\x04b\x02U\ + \x10\n\x0c\n\x05\x04\0\x02\x04\x06\x12\x03b\x02\x15\n\x0c\n\x05\x04\0\ + \x02\x04\x01\x12\x03b\x16\x1c\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03b\x1f\ + \x20\n\xc9\x01\n\x02\x04\x01\x12\x05h\0\x9a\x01\x01\x1a\xbb\x01\x20A\x20\ + resizable\x20group\x20of\x20nodes\x20in\x20a\x20particular\x20cloud\x20l\ + ocation,\x20capable\n\x20of\x20serving\x20all\x20[Tables][google.bigtabl\ + e.admin.v2.Table]\x20in\x20the\x20parent\n\x20[Instance][google.bigtable\ + .admin.v2.Instance].\n\n\n\n\x03\x04\x01\x01\x12\x03h\x08\x0f\n.\n\x04\ + \x04\x01\x04\0\x12\x05j\x02\x80\x01\x03\x1a\x1f\x20Possible\x20states\ + \x20of\x20a\x20cluster.\n\n\x0c\n\x05\x04\x01\x04\0\x01\x12\x03j\x07\x0c\ + \nB\n\x06\x04\x01\x04\0\x02\0\x12\x03l\x04\x18\x1a3\x20The\x20state\x20o\ + f\x20the\x20cluster\x20could\x20not\x20be\x20determined.\n\n\x0e\n\x07\ + \x04\x01\x04\0\x02\0\x01\x12\x03l\x04\x13\n\x0e\n\x07\x04\x01\x04\0\x02\ + \0\x02\x12\x03l\x16\x17\nZ\n\x06\x04\x01\x04\0\x02\x01\x12\x03o\x04\x0e\ + \x1aK\x20The\x20cluster\x20has\x20been\x20successfully\x20created\x20and\ + \x20is\x20ready\x20to\x20serve\x20requests.\n\n\x0e\n\x07\x04\x01\x04\0\ + \x02\x01\x01\x12\x03o\x04\t\n\x0e\n\x07\x04\x01\x04\0\x02\x01\x02\x12\ + \x03o\x0c\r\n\xbe\x01\n\x06\x04\x01\x04\0\x02\x02\x12\x03t\x04\x11\x1a\ + \xae\x01\x20The\x20cluster\x20is\x20currently\x20being\x20created,\x20an\ + d\x20may\x20be\x20destroyed\n\x20if\x20the\x20creation\x20process\x20enc\ + ounters\x20an\x20error.\n\x20A\x20cluster\x20may\x20not\x20be\x20able\ + \x20to\x20serve\x20requests\x20while\x20being\x20created.\n\n\x0e\n\x07\ + \x04\x01\x04\0\x02\x02\x01\x12\x03t\x04\x0c\n\x0e\n\x07\x04\x01\x04\0\ + \x02\x02\x02\x12\x03t\x0f\x10\n\xbd\x02\n\x06\x04\x01\x04\0\x02\x03\x12\ + \x03{\x04\x11\x1a\xad\x02\x20The\x20cluster\x20is\x20currently\x20being\ + \x20resized,\x20and\x20may\x20revert\x20to\x20its\x20previous\n\x20node\ + \x20count\x20if\x20the\x20process\x20encounters\x20an\x20error.\n\x20A\ + \x20cluster\x20is\x20still\x20capable\x20of\x20serving\x20requests\x20wh\ + ile\x20being\x20resized,\n\x20but\x20may\x20exhibit\x20performance\x20as\ + \x20if\x20its\x20number\x20of\x20allocated\x20nodes\x20is\n\x20between\ + \x20the\x20starting\x20and\x20requested\x20states.\n\n\x0e\n\x07\x04\x01\ + \x04\0\x02\x03\x01\x12\x03{\x04\x0c\n\x0e\n\x07\x04\x01\x04\0\x02\x03\ + \x02\x12\x03{\x0f\x10\n\x85\x01\n\x06\x04\x01\x04\0\x02\x04\x12\x03\x7f\ + \x04\x11\x1av\x20The\x20cluster\x20has\x20no\x20backing\x20nodes.\x20The\ + \x20data\x20(tables)\x20still\n\x20exist,\x20but\x20no\x20operations\x20\ + can\x20be\x20performed\x20on\x20the\x20cluster.\n\n\x0e\n\x07\x04\x01\ + \x04\0\x02\x04\x01\x12\x03\x7f\x04\x0c\n\x0e\n\x07\x04\x01\x04\0\x02\x04\ + \x02\x12\x03\x7f\x0f\x10\n\x9c\x01\n\x04\x04\x01\x02\0\x12\x04\x85\x01\ + \x02\x12\x1a\x8d\x01\x20(`OutputOnly`)\n\x20The\x20unique\x20name\x20of\ + \x20the\x20cluster.\x20Values\x20are\x20of\x20the\x20form\n\x20`projects\ + //instances//clusters/[a-z][-a-z0-9]*`.\n\n\x0f\n\x05\ + \x04\x01\x02\0\x04\x12\x06\x85\x01\x02\x80\x01\x03\n\r\n\x05\x04\x01\x02\ + \0\x05\x12\x04\x85\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\x85\ + \x01\t\r\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\x85\x01\x10\x11\n\xa2\x02\n\ + \x04\x04\x01\x02\x01\x12\x04\x8c\x01\x02\x16\x1a\x93\x02\x20(`CreationOn\ + ly`)\n\x20The\x20location\x20where\x20this\x20cluster's\x20nodes\x20and\ + \x20storage\x20reside.\x20For\x20best\n\x20performance,\x20clients\x20sh\ + ould\x20be\x20located\x20as\x20close\x20as\x20possible\x20to\x20this\n\ + \x20cluster.\x20Currently\x20only\x20zones\x20are\x20supported,\x20so\ + \x20values\x20should\x20be\x20of\x20the\n\x20form\x20`projects/\ + /locations/`.\n\n\x0f\n\x05\x04\x01\x02\x01\x04\x12\x06\x8c\x01\ + \x02\x85\x01\x12\n\r\n\x05\x04\x01\x02\x01\x05\x12\x04\x8c\x01\x02\x08\n\ + \r\n\x05\x04\x01\x02\x01\x01\x12\x04\x8c\x01\t\x11\n\r\n\x05\x04\x01\x02\ + \x01\x03\x12\x04\x8c\x01\x14\x15\nA\n\x04\x04\x01\x02\x02\x12\x04\x90\ + \x01\x02\x12\x1a3\x20(`OutputOnly`)\n\x20The\x20current\x20state\x20of\ + \x20the\x20cluster.\n\n\x0f\n\x05\x04\x01\x02\x02\x04\x12\x06\x90\x01\ + \x02\x8c\x01\x16\n\r\n\x05\x04\x01\x02\x02\x06\x12\x04\x90\x01\x02\x07\n\ + \r\n\x05\x04\x01\x02\x02\x01\x12\x04\x90\x01\x08\r\n\r\n\x05\x04\x01\x02\ + \x02\x03\x12\x04\x90\x01\x10\x11\n\x84\x01\n\x04\x04\x01\x02\x03\x12\x04\ + \x94\x01\x02\x18\x1av\x20The\x20number\x20of\x20nodes\x20allocated\x20to\ + \x20this\x20cluster.\x20More\x20nodes\x20enable\x20higher\n\x20throughpu\ + t\x20and\x20more\x20consistent\x20performance.\n\n\x0f\n\x05\x04\x01\x02\ + \x03\x04\x12\x06\x94\x01\x02\x90\x01\x12\n\r\n\x05\x04\x01\x02\x03\x05\ + \x12\x04\x94\x01\x02\x07\n\r\n\x05\x04\x01\x02\x03\x01\x12\x04\x94\x01\ + \x08\x13\n\r\n\x05\x04\x01\x02\x03\x03\x12\x04\x94\x01\x16\x17\n\x91\x01\ + \n\x04\x04\x01\x02\x04\x12\x04\x99\x01\x02'\x1a\x82\x01\x20(`CreationOnl\ + y`)\n\x20The\x20type\x20of\x20storage\x20used\x20by\x20this\x20cluster\ + \x20to\x20serve\x20its\n\x20parent\x20instance's\x20tables,\x20unless\ + \x20explicitly\x20overridden.\n\n\x0f\n\x05\x04\x01\x02\x04\x04\x12\x06\ + \x99\x01\x02\x94\x01\x18\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\x99\x01\ + \x02\r\n\r\n\x05\x04\x01\x02\x04\x01\x12\x04\x99\x01\x0e\"\n\r\n\x05\x04\ + \x01\x02\x04\x03\x12\x04\x99\x01%&\n\x82\x01\n\x02\x04\x02\x12\x06\x9e\ + \x01\0\xcf\x01\x01\x1at\x20A\x20configuration\x20object\x20describing\ + \x20how\x20Cloud\x20Bigtable\x20should\x20treat\x20traffic\n\x20from\x20\ + a\x20particular\x20end\x20user\x20application.\n\n\x0b\n\x03\x04\x02\x01\ + \x12\x04\x9e\x01\x08\x12\n\xff\x01\n\x04\x04\x02\x03\0\x12\x06\xa3\x01\ + \x02\xa5\x01\x03\x1a\xee\x01\x20Read/write\x20requests\x20may\x20be\x20r\ + outed\x20to\x20any\x20cluster\x20in\x20the\x20instance,\x20and\x20will\n\ + \x20fail\x20over\x20to\x20another\x20cluster\x20in\x20the\x20event\x20of\ + \x20transient\x20errors\x20or\x20delays.\n\x20Choosing\x20this\x20option\ + \x20sacrifices\x20read-your-writes\x20consistency\x20to\x20improve\n\x20\ + availability.\n\n\r\n\x05\x04\x02\x03\0\x01\x12\x04\xa3\x01\n#\n\xb1\x01\ + \n\x04\x04\x02\x03\x01\x12\x06\xaa\x01\x02\xb2\x01\x03\x1a\xa0\x01\x20Un\ + conditionally\x20routes\x20all\x20read/write\x20requests\x20to\x20a\x20s\ + pecific\x20cluster.\n\x20This\x20option\x20preserves\x20read-your-writes\ + \x20consistency,\x20but\x20does\x20not\x20improve\n\x20availability.\n\n\ + \r\n\x05\x04\x02\x03\x01\x01\x12\x04\xaa\x01\n\x1e\nL\n\x06\x04\x02\x03\ + \x01\x02\0\x12\x04\xac\x01\x04\x1a\x1a<\x20The\x20cluster\x20to\x20which\ + \x20read/write\x20requests\x20should\x20be\x20routed.\n\n\x11\n\x07\x04\ + \x02\x03\x01\x02\0\x04\x12\x06\xac\x01\x04\xaa\x01\x20\n\x0f\n\x07\x04\ + \x02\x03\x01\x02\0\x05\x12\x04\xac\x01\x04\n\n\x0f\n\x07\x04\x02\x03\x01\ + \x02\0\x01\x12\x04\xac\x01\x0b\x15\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x03\ + \x12\x04\xac\x01\x18\x19\n\xd1\x01\n\x06\x04\x02\x03\x01\x02\x01\x12\x04\ + \xb1\x01\x04(\x1a\xc0\x01\x20Whether\x20or\x20not\x20`CheckAndMutateRow`\ + \x20and\x20`ReadModifyWriteRow`\x20requests\x20are\n\x20allowed\x20by\ + \x20this\x20app\x20profile.\x20It\x20is\x20unsafe\x20to\x20send\x20these\ + \x20requests\x20to\n\x20the\x20same\x20table/row/column\x20in\x20multipl\ + e\x20clusters.\n\n\x11\n\x07\x04\x02\x03\x01\x02\x01\x04\x12\x06\xb1\x01\ + \x04\xac\x01\x1a\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x05\x12\x04\xb1\x01\ + \x04\x08\n\x0f\n\x07\x04\x02\x03\x01\x02\x01\x01\x12\x04\xb1\x01\t#\n\ + \x0f\n\x07\x04\x02\x03\x01\x02\x01\x03\x12\x04\xb1\x01&'\n\xaf\x01\n\x04\ + \x04\x02\x02\0\x12\x04\xb7\x01\x02\x12\x1a\xa0\x01\x20(`OutputOnly`)\n\ + \x20The\x20unique\x20name\x20of\x20the\x20app\x20profile.\x20Values\x20a\ + re\x20of\x20the\x20form\n\x20`projects//instances//ap\ + pProfiles/[_a-zA-Z0-9][-_.a-zA-Z0-9]*`.\n\n\x0f\n\x05\x04\x02\x02\0\x04\ + \x12\x06\xb7\x01\x02\xb2\x01\x03\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xb7\ + \x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xb7\x01\t\r\n\r\n\x05\ + \x04\x02\x02\0\x03\x12\x04\xb7\x01\x10\x11\n\xcd\x03\n\x04\x04\x02\x02\ + \x01\x12\x04\xc1\x01\x02\x12\x1a\xbe\x03\x20Strongly\x20validated\x20eta\ + g\x20for\x20optimistic\x20concurrency\x20control.\x20Preserve\x20the\n\ + \x20value\x20returned\x20from\x20`GetAppProfile`\x20when\x20calling\x20`\ + UpdateAppProfile`\x20to\n\x20fail\x20the\x20request\x20if\x20there\x20ha\ + s\x20been\x20a\x20modification\x20in\x20the\x20mean\x20time.\x20The\n\ + \x20`update_mask`\x20of\x20the\x20request\x20need\x20not\x20include\x20`\ + etag`\x20for\x20this\x20protection\n\x20to\x20apply.\n\x20See\x20[Wikipe\ + dia](https://en.wikipedia.org/wiki/HTTP_ETag)\x20and\n\x20[RFC\x207232](\ + https://tools.ietf.org/html/rfc7232#section-2.3)\x20for\x20more\n\x20det\ + ails.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\x06\xc1\x01\x02\xb7\x01\x12\ + \n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xc1\x01\x02\x08\n\r\n\x05\x04\x02\ + \x02\x01\x01\x12\x04\xc1\x01\t\r\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\ + \xc1\x01\x10\x11\nS\n\x04\x04\x02\x02\x02\x12\x04\xc4\x01\x02\x19\x1aE\ + \x20Optional\x20long\x20form\x20description\x20of\x20the\x20use\x20case\ + \x20for\x20this\x20AppProfile.\n\n\x0f\n\x05\x04\x02\x02\x02\x04\x12\x06\ + \xc4\x01\x02\xc1\x01\x12\n\r\n\x05\x04\x02\x02\x02\x05\x12\x04\xc4\x01\ + \x02\x08\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xc4\x01\t\x14\n\r\n\x05\ + \x04\x02\x02\x02\x03\x12\x04\xc4\x01\x17\x18\n}\n\x04\x04\x02\x08\0\x12\ + \x06\xc8\x01\x02\xce\x01\x03\x1am\x20The\x20routing\x20policy\x20for\x20\ + all\x20read/write\x20requests\x20which\x20use\x20this\x20app\x20profile.\ + \n\x20A\x20value\x20must\x20be\x20explicitly\x20set.\n\n\r\n\x05\x04\x02\ + \x08\0\x01\x12\x04\xc8\x01\x08\x16\nM\n\x04\x04\x02\x02\x03\x12\x04\xca\ + \x01\x04@\x1a?\x20Use\x20a\x20multi-cluster\x20routing\x20policy\x20that\ + \x20may\x20pick\x20any\x20cluster.\n\n\r\n\x05\x04\x02\x02\x03\x06\x12\ + \x04\xca\x01\x04\x1d\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\xca\x01\x1e;\ + \n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\xca\x01>?\n4\n\x04\x04\x02\x02\ + \x04\x12\x04\xcd\x01\x044\x1a&\x20Use\x20a\x20single-cluster\x20routing\ + \x20policy.\n\n\r\n\x05\x04\x02\x02\x04\x06\x12\x04\xcd\x01\x04\x18\n\r\ + \n\x05\x04\x02\x02\x04\x01\x12\x04\xcd\x01\x19/\n\r\n\x05\x04\x02\x02\ + \x04\x03\x12\x04\xcd\x0123b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/mod.rs new file mode 100644 index 00000000..e9b02d7a --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/mod.rs @@ -0,0 +1,11 @@ +pub mod bigtable_instance_admin; +pub mod bigtable_instance_admin_grpc; +pub mod bigtable_table_admin; +pub mod bigtable_table_admin_grpc; +pub mod common; +pub mod instance; +pub mod table; + +pub(crate) use crate::empty; +pub(crate) use crate::iam::v1::{iam_policy, policy}; +pub(crate) use crate::longrunning::operations; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/table.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/table.rs new file mode 100644 index 00000000..d10d4136 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/admin/v2/table.rs @@ -0,0 +1,2408 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/admin/v2/table.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Table { + // message fields + pub name: ::std::string::String, + pub cluster_states: ::std::collections::HashMap<::std::string::String, Table_ClusterState>, + pub column_families: ::std::collections::HashMap<::std::string::String, ColumnFamily>, + pub granularity: Table_TimestampGranularity, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Table { + fn default() -> &'a Table { +
::default_instance() + } +} + +impl Table { + pub fn new() -> Table { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.bigtable.admin.v2.Table.ClusterStatesEntry cluster_states = 2; + + + pub fn get_cluster_states(&self) -> &::std::collections::HashMap<::std::string::String, Table_ClusterState> { + &self.cluster_states + } + pub fn clear_cluster_states(&mut self) { + self.cluster_states.clear(); + } + + // Param is passed by value, moved + pub fn set_cluster_states(&mut self, v: ::std::collections::HashMap<::std::string::String, Table_ClusterState>) { + self.cluster_states = v; + } + + // Mutable pointer to the field. + pub fn mut_cluster_states(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, Table_ClusterState> { + &mut self.cluster_states + } + + // Take field + pub fn take_cluster_states(&mut self) -> ::std::collections::HashMap<::std::string::String, Table_ClusterState> { + ::std::mem::replace(&mut self.cluster_states, ::std::collections::HashMap::new()) + } + + // repeated .google.bigtable.admin.v2.Table.ColumnFamiliesEntry column_families = 3; + + + pub fn get_column_families(&self) -> &::std::collections::HashMap<::std::string::String, ColumnFamily> { + &self.column_families + } + pub fn clear_column_families(&mut self) { + self.column_families.clear(); + } + + // Param is passed by value, moved + pub fn set_column_families(&mut self, v: ::std::collections::HashMap<::std::string::String, ColumnFamily>) { + self.column_families = v; + } + + // Mutable pointer to the field. + pub fn mut_column_families(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ColumnFamily> { + &mut self.column_families + } + + // Take field + pub fn take_column_families(&mut self) -> ::std::collections::HashMap<::std::string::String, ColumnFamily> { + ::std::mem::replace(&mut self.column_families, ::std::collections::HashMap::new()) + } + + // .google.bigtable.admin.v2.Table.TimestampGranularity granularity = 4; + + + pub fn get_granularity(&self) -> Table_TimestampGranularity { + self.granularity + } + pub fn clear_granularity(&mut self) { + self.granularity = Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_granularity(&mut self, v: Table_TimestampGranularity) { + self.granularity = v; + } +} + +impl ::protobuf::Message for Table { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.cluster_states)?; + }, + 3 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.column_families)?; + }, + 4 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.granularity, 4, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(2, &self.cluster_states); + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(3, &self.column_families); + if self.granularity != Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(4, self.granularity); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(2, &self.cluster_states, os)?; + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(3, &self.column_families, os)?; + if self.granularity != Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED { + os.write_enum(4, self.granularity.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Table { + Table::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Table| { &m.name }, + |m: &mut Table| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "cluster_states", + |m: &Table| { &m.cluster_states }, + |m: &mut Table| { &mut m.cluster_states }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "column_families", + |m: &Table| { &m.column_families }, + |m: &mut Table| { &mut m.column_families }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "granularity", + |m: &Table| { &m.granularity }, + |m: &mut Table| { &mut m.granularity }, + )); + ::protobuf::reflect::MessageDescriptor::new::
( + "Table", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Table { + static mut instance: ::protobuf::lazy::Lazy
= ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Table, + }; + unsafe { + instance.get(Table::new) + } + } +} + +impl ::protobuf::Clear for Table { + fn clear(&mut self) { + self.name.clear(); + self.cluster_states.clear(); + self.column_families.clear(); + self.granularity = Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Table { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Table { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Table_ClusterState { + // message fields + pub replication_state: Table_ClusterState_ReplicationState, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Table_ClusterState { + fn default() -> &'a Table_ClusterState { + ::default_instance() + } +} + +impl Table_ClusterState { + pub fn new() -> Table_ClusterState { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.Table.ClusterState.ReplicationState replication_state = 1; + + + pub fn get_replication_state(&self) -> Table_ClusterState_ReplicationState { + self.replication_state + } + pub fn clear_replication_state(&mut self) { + self.replication_state = Table_ClusterState_ReplicationState::STATE_NOT_KNOWN; + } + + // Param is passed by value, moved + pub fn set_replication_state(&mut self, v: Table_ClusterState_ReplicationState) { + self.replication_state = v; + } +} + +impl ::protobuf::Message for Table_ClusterState { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.replication_state, 1, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.replication_state != Table_ClusterState_ReplicationState::STATE_NOT_KNOWN { + my_size += ::protobuf::rt::enum_size(1, self.replication_state); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.replication_state != Table_ClusterState_ReplicationState::STATE_NOT_KNOWN { + os.write_enum(1, self.replication_state.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Table_ClusterState { + Table_ClusterState::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "replication_state", + |m: &Table_ClusterState| { &m.replication_state }, + |m: &mut Table_ClusterState| { &mut m.replication_state }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Table_ClusterState", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Table_ClusterState { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Table_ClusterState, + }; + unsafe { + instance.get(Table_ClusterState::new) + } + } +} + +impl ::protobuf::Clear for Table_ClusterState { + fn clear(&mut self) { + self.replication_state = Table_ClusterState_ReplicationState::STATE_NOT_KNOWN; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Table_ClusterState { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Table_ClusterState { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Table_ClusterState_ReplicationState { + STATE_NOT_KNOWN = 0, + INITIALIZING = 1, + PLANNED_MAINTENANCE = 2, + UNPLANNED_MAINTENANCE = 3, + READY = 4, +} + +impl ::protobuf::ProtobufEnum for Table_ClusterState_ReplicationState { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Table_ClusterState_ReplicationState::STATE_NOT_KNOWN), + 1 => ::std::option::Option::Some(Table_ClusterState_ReplicationState::INITIALIZING), + 2 => ::std::option::Option::Some(Table_ClusterState_ReplicationState::PLANNED_MAINTENANCE), + 3 => ::std::option::Option::Some(Table_ClusterState_ReplicationState::UNPLANNED_MAINTENANCE), + 4 => ::std::option::Option::Some(Table_ClusterState_ReplicationState::READY), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Table_ClusterState_ReplicationState] = &[ + Table_ClusterState_ReplicationState::STATE_NOT_KNOWN, + Table_ClusterState_ReplicationState::INITIALIZING, + Table_ClusterState_ReplicationState::PLANNED_MAINTENANCE, + Table_ClusterState_ReplicationState::UNPLANNED_MAINTENANCE, + Table_ClusterState_ReplicationState::READY, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Table_ClusterState_ReplicationState", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Table_ClusterState_ReplicationState { +} + +impl ::std::default::Default for Table_ClusterState_ReplicationState { + fn default() -> Self { + Table_ClusterState_ReplicationState::STATE_NOT_KNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Table_ClusterState_ReplicationState { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Table_TimestampGranularity { + TIMESTAMP_GRANULARITY_UNSPECIFIED = 0, + MILLIS = 1, +} + +impl ::protobuf::ProtobufEnum for Table_TimestampGranularity { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED), + 1 => ::std::option::Option::Some(Table_TimestampGranularity::MILLIS), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Table_TimestampGranularity] = &[ + Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED, + Table_TimestampGranularity::MILLIS, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Table_TimestampGranularity", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Table_TimestampGranularity { +} + +impl ::std::default::Default for Table_TimestampGranularity { + fn default() -> Self { + Table_TimestampGranularity::TIMESTAMP_GRANULARITY_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for Table_TimestampGranularity { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Table_View { + VIEW_UNSPECIFIED = 0, + NAME_ONLY = 1, + SCHEMA_VIEW = 2, + REPLICATION_VIEW = 3, + FULL = 4, +} + +impl ::protobuf::ProtobufEnum for Table_View { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Table_View::VIEW_UNSPECIFIED), + 1 => ::std::option::Option::Some(Table_View::NAME_ONLY), + 2 => ::std::option::Option::Some(Table_View::SCHEMA_VIEW), + 3 => ::std::option::Option::Some(Table_View::REPLICATION_VIEW), + 4 => ::std::option::Option::Some(Table_View::FULL), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Table_View] = &[ + Table_View::VIEW_UNSPECIFIED, + Table_View::NAME_ONLY, + Table_View::SCHEMA_VIEW, + Table_View::REPLICATION_VIEW, + Table_View::FULL, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Table_View", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Table_View { +} + +impl ::std::default::Default for Table_View { + fn default() -> Self { + Table_View::VIEW_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for Table_View { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ColumnFamily { + // message fields + pub gc_rule: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ColumnFamily { + fn default() -> &'a ColumnFamily { + ::default_instance() + } +} + +impl ColumnFamily { + pub fn new() -> ColumnFamily { + ::std::default::Default::default() + } + + // .google.bigtable.admin.v2.GcRule gc_rule = 1; + + + pub fn get_gc_rule(&self) -> &GcRule { + self.gc_rule.as_ref().unwrap_or_else(|| GcRule::default_instance()) + } + pub fn clear_gc_rule(&mut self) { + self.gc_rule.clear(); + } + + pub fn has_gc_rule(&self) -> bool { + self.gc_rule.is_some() + } + + // Param is passed by value, moved + pub fn set_gc_rule(&mut self, v: GcRule) { + self.gc_rule = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gc_rule(&mut self) -> &mut GcRule { + if self.gc_rule.is_none() { + self.gc_rule.set_default(); + } + self.gc_rule.as_mut().unwrap() + } + + // Take field + pub fn take_gc_rule(&mut self) -> GcRule { + self.gc_rule.take().unwrap_or_else(|| GcRule::new()) + } +} + +impl ::protobuf::Message for ColumnFamily { + fn is_initialized(&self) -> bool { + for v in &self.gc_rule { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.gc_rule)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.gc_rule.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.gc_rule.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ColumnFamily { + ColumnFamily::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "gc_rule", + |m: &ColumnFamily| { &m.gc_rule }, + |m: &mut ColumnFamily| { &mut m.gc_rule }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ColumnFamily", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ColumnFamily { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ColumnFamily, + }; + unsafe { + instance.get(ColumnFamily::new) + } + } +} + +impl ::protobuf::Clear for ColumnFamily { + fn clear(&mut self) { + self.gc_rule.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ColumnFamily { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ColumnFamily { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule { + // message oneof groups + pub rule: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule { + fn default() -> &'a GcRule { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum GcRule_oneof_rule { + max_num_versions(i32), + max_age(::protobuf::well_known_types::Duration), + intersection(GcRule_Intersection), + union(GcRule_Union), +} + +impl GcRule { + pub fn new() -> GcRule { + ::std::default::Default::default() + } + + // int32 max_num_versions = 1; + + + pub fn get_max_num_versions(&self) -> i32 { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(v)) => v, + _ => 0, + } + } + pub fn clear_max_num_versions(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_max_num_versions(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_max_num_versions(&mut self, v: i32) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(v)) + } + + // .google.protobuf.Duration max_age = 2; + + + pub fn get_max_age(&self) -> &::protobuf::well_known_types::Duration { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(ref v)) => v, + _ => ::protobuf::well_known_types::Duration::default_instance(), + } + } + pub fn clear_max_age(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_max_age(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_max_age(&mut self, v: ::protobuf::well_known_types::Duration) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(v)) + } + + // Mutable pointer to the field. + pub fn mut_max_age(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if let ::std::option::Option::Some(GcRule_oneof_rule::max_age(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(::protobuf::well_known_types::Duration::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_max_age(&mut self) -> ::protobuf::well_known_types::Duration { + if self.has_max_age() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::max_age(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Duration::new() + } + } + + // .google.bigtable.admin.v2.GcRule.Intersection intersection = 3; + + + pub fn get_intersection(&self) -> &GcRule_Intersection { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(ref v)) => v, + _ => GcRule_Intersection::default_instance(), + } + } + pub fn clear_intersection(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_intersection(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_intersection(&mut self, v: GcRule_Intersection) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(v)) + } + + // Mutable pointer to the field. + pub fn mut_intersection(&mut self) -> &mut GcRule_Intersection { + if let ::std::option::Option::Some(GcRule_oneof_rule::intersection(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(GcRule_Intersection::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_intersection(&mut self) -> GcRule_Intersection { + if self.has_intersection() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::intersection(v)) => v, + _ => panic!(), + } + } else { + GcRule_Intersection::new() + } + } + + // .google.bigtable.admin.v2.GcRule.Union union = 4; + + + pub fn get_union(&self) -> &GcRule_Union { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(ref v)) => v, + _ => GcRule_Union::default_instance(), + } + } + pub fn clear_union(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_union(&self) -> bool { + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_union(&mut self, v: GcRule_Union) { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(v)) + } + + // Mutable pointer to the field. + pub fn mut_union(&mut self) -> &mut GcRule_Union { + if let ::std::option::Option::Some(GcRule_oneof_rule::union(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(GcRule_Union::new())); + } + match self.rule { + ::std::option::Option::Some(GcRule_oneof_rule::union(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_union(&mut self) -> GcRule_Union { + if self.has_union() { + match self.rule.take() { + ::std::option::Option::Some(GcRule_oneof_rule::union(v)) => v, + _ => panic!(), + } + } else { + GcRule_Union::new() + } + } +} + +impl ::protobuf::Message for GcRule { + fn is_initialized(&self) -> bool { + if let Some(GcRule_oneof_rule::max_age(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + if let Some(GcRule_oneof_rule::intersection(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + if let Some(GcRule_oneof_rule::union(ref v)) = self.rule { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_num_versions(is.read_int32()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::max_age(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::intersection(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(GcRule_oneof_rule::union(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &GcRule_oneof_rule::max_num_versions(v) => { + my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); + }, + &GcRule_oneof_rule::max_age(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &GcRule_oneof_rule::intersection(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &GcRule_oneof_rule::union(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &GcRule_oneof_rule::max_num_versions(v) => { + os.write_int32(1, v)?; + }, + &GcRule_oneof_rule::max_age(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &GcRule_oneof_rule::intersection(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &GcRule_oneof_rule::union(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule { + GcRule::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "max_num_versions", + GcRule::has_max_num_versions, + GcRule::get_max_num_versions, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>( + "max_age", + GcRule::has_max_age, + GcRule::get_max_age, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, GcRule_Intersection>( + "intersection", + GcRule::has_intersection, + GcRule::get_intersection, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, GcRule_Union>( + "union", + GcRule::has_union, + GcRule::get_union, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule, + }; + unsafe { + instance.get(GcRule::new) + } + } +} + +impl ::protobuf::Clear for GcRule { + fn clear(&mut self) { + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule_Intersection { + // message fields + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule_Intersection { + fn default() -> &'a GcRule_Intersection { + ::default_instance() + } +} + +impl GcRule_Intersection { + pub fn new() -> GcRule_Intersection { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.GcRule rules = 1; + + + pub fn get_rules(&self) -> &[GcRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GcRule_Intersection { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.rules { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule_Intersection { + GcRule_Intersection::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &GcRule_Intersection| { &m.rules }, + |m: &mut GcRule_Intersection| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule_Intersection", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule_Intersection { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule_Intersection, + }; + unsafe { + instance.get(GcRule_Intersection::new) + } + } +} + +impl ::protobuf::Clear for GcRule_Intersection { + fn clear(&mut self) { + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule_Intersection { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule_Intersection { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GcRule_Union { + // message fields + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GcRule_Union { + fn default() -> &'a GcRule_Union { + ::default_instance() + } +} + +impl GcRule_Union { + pub fn new() -> GcRule_Union { + ::std::default::Default::default() + } + + // repeated .google.bigtable.admin.v2.GcRule rules = 1; + + + pub fn get_rules(&self) -> &[GcRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GcRule_Union { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.rules { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GcRule_Union { + GcRule_Union::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &GcRule_Union| { &m.rules }, + |m: &mut GcRule_Union| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GcRule_Union", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GcRule_Union { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GcRule_Union, + }; + unsafe { + instance.get(GcRule_Union::new) + } + } +} + +impl ::protobuf::Clear for GcRule_Union { + fn clear(&mut self) { + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GcRule_Union { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GcRule_Union { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Snapshot { + // message fields + pub name: ::std::string::String, + pub source_table: ::protobuf::SingularPtrField
, + pub data_size_bytes: i64, + pub create_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub delete_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub state: Snapshot_State, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Snapshot { + fn default() -> &'a Snapshot { + ::default_instance() + } +} + +impl Snapshot { + pub fn new() -> Snapshot { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.bigtable.admin.v2.Table source_table = 2; + + + pub fn get_source_table(&self) -> &Table { + self.source_table.as_ref().unwrap_or_else(|| Table::default_instance()) + } + pub fn clear_source_table(&mut self) { + self.source_table.clear(); + } + + pub fn has_source_table(&self) -> bool { + self.source_table.is_some() + } + + // Param is passed by value, moved + pub fn set_source_table(&mut self, v: Table) { + self.source_table = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_table(&mut self) -> &mut Table { + if self.source_table.is_none() { + self.source_table.set_default(); + } + self.source_table.as_mut().unwrap() + } + + // Take field + pub fn take_source_table(&mut self) -> Table { + self.source_table.take().unwrap_or_else(|| Table::new()) + } + + // int64 data_size_bytes = 3; + + + pub fn get_data_size_bytes(&self) -> i64 { + self.data_size_bytes + } + pub fn clear_data_size_bytes(&mut self) { + self.data_size_bytes = 0; + } + + // Param is passed by value, moved + pub fn set_data_size_bytes(&mut self, v: i64) { + self.data_size_bytes = v; + } + + // .google.protobuf.Timestamp create_time = 4; + + + pub fn get_create_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.create_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_create_time(&mut self) { + self.create_time.clear(); + } + + pub fn has_create_time(&self) -> bool { + self.create_time.is_some() + } + + // Param is passed by value, moved + pub fn set_create_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.create_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_create_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.create_time.is_none() { + self.create_time.set_default(); + } + self.create_time.as_mut().unwrap() + } + + // Take field + pub fn take_create_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.create_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp delete_time = 5; + + + pub fn get_delete_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.delete_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_delete_time(&mut self) { + self.delete_time.clear(); + } + + pub fn has_delete_time(&self) -> bool { + self.delete_time.is_some() + } + + // Param is passed by value, moved + pub fn set_delete_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.delete_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_delete_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.delete_time.is_none() { + self.delete_time.set_default(); + } + self.delete_time.as_mut().unwrap() + } + + // Take field + pub fn take_delete_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.delete_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.bigtable.admin.v2.Snapshot.State state = 6; + + + pub fn get_state(&self) -> Snapshot_State { + self.state + } + pub fn clear_state(&mut self) { + self.state = Snapshot_State::STATE_NOT_KNOWN; + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: Snapshot_State) { + self.state = v; + } + + // string description = 7; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Snapshot { + fn is_initialized(&self) -> bool { + for v in &self.source_table { + if !v.is_initialized() { + return false; + } + }; + for v in &self.create_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.delete_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_table)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.data_size_bytes = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_time)?; + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.delete_time)?; + }, + 6 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 6, &mut self.unknown_fields)? + }, + 7 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.source_table.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.data_size_bytes != 0 { + my_size += ::protobuf::rt::value_size(3, self.data_size_bytes, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(ref v) = self.create_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.delete_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.state != Snapshot_State::STATE_NOT_KNOWN { + my_size += ::protobuf::rt::enum_size(6, self.state); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(7, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.source_table.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.data_size_bytes != 0 { + os.write_int64(3, self.data_size_bytes)?; + } + if let Some(ref v) = self.create_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.delete_time.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.state != Snapshot_State::STATE_NOT_KNOWN { + os.write_enum(6, self.state.value())?; + } + if !self.description.is_empty() { + os.write_string(7, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Snapshot { + Snapshot::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Snapshot| { &m.name }, + |m: &mut Snapshot| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage
>( + "source_table", + |m: &Snapshot| { &m.source_table }, + |m: &mut Snapshot| { &mut m.source_table }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "data_size_bytes", + |m: &Snapshot| { &m.data_size_bytes }, + |m: &mut Snapshot| { &mut m.data_size_bytes }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "create_time", + |m: &Snapshot| { &m.create_time }, + |m: &mut Snapshot| { &mut m.create_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "delete_time", + |m: &Snapshot| { &m.delete_time }, + |m: &mut Snapshot| { &mut m.delete_time }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "state", + |m: &Snapshot| { &m.state }, + |m: &mut Snapshot| { &mut m.state }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &Snapshot| { &m.description }, + |m: &mut Snapshot| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Snapshot", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Snapshot { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Snapshot, + }; + unsafe { + instance.get(Snapshot::new) + } + } +} + +impl ::protobuf::Clear for Snapshot { + fn clear(&mut self) { + self.name.clear(); + self.source_table.clear(); + self.data_size_bytes = 0; + self.create_time.clear(); + self.delete_time.clear(); + self.state = Snapshot_State::STATE_NOT_KNOWN; + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Snapshot { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Snapshot { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Snapshot_State { + STATE_NOT_KNOWN = 0, + READY = 1, + CREATING = 2, +} + +impl ::protobuf::ProtobufEnum for Snapshot_State { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Snapshot_State::STATE_NOT_KNOWN), + 1 => ::std::option::Option::Some(Snapshot_State::READY), + 2 => ::std::option::Option::Some(Snapshot_State::CREATING), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Snapshot_State] = &[ + Snapshot_State::STATE_NOT_KNOWN, + Snapshot_State::READY, + Snapshot_State::CREATING, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Snapshot_State", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Snapshot_State { +} + +impl ::std::default::Default for Snapshot_State { + fn default() -> Self { + Snapshot_State::STATE_NOT_KNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Snapshot_State { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n$google/bigtable/admin/v2/table.proto\x12\x18google.bigtable.admin.v2\ + \x1a\x1cgoogle/api/annotations.proto\x1a\x1egoogle/protobuf/duration.pro\ + to\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa7\x07\n\x05Table\x12\x12\n\ + \x04name\x18\x01\x20\x01(\tR\x04name\x12Y\n\x0ecluster_states\x18\x02\ + \x20\x03(\x0b22.google.bigtable.admin.v2.Table.ClusterStatesEntryR\rclus\ + terStates\x12\\\n\x0fcolumn_families\x18\x03\x20\x03(\x0b23.google.bigta\ + ble.admin.v2.Table.ColumnFamiliesEntryR\x0ecolumnFamilies\x12V\n\x0bgran\ + ularity\x18\x04\x20\x01(\x0e24.google.bigtable.admin.v2.Table.TimestampG\ + ranularityR\x0bgranularity\x1a\xf4\x01\n\x0cClusterState\x12j\n\x11repli\ + cation_state\x18\x01\x20\x01(\x0e2=.google.bigtable.admin.v2.Table.Clust\ + erState.ReplicationStateR\x10replicationState\"x\n\x10ReplicationState\ + \x12\x13\n\x0fSTATE_NOT_KNOWN\x10\0\x12\x10\n\x0cINITIALIZING\x10\x01\ + \x12\x17\n\x13PLANNED_MAINTENANCE\x10\x02\x12\x19\n\x15UNPLANNED_MAINTEN\ + ANCE\x10\x03\x12\t\n\x05READY\x10\x04\x1an\n\x12ClusterStatesEntry\x12\ + \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12B\n\x05value\x18\x02\x20\x01\ + (\x0b2,.google.bigtable.admin.v2.Table.ClusterStateR\x05value:\x028\x01\ + \x1ai\n\x13ColumnFamiliesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03k\ + ey\x12<\n\x05value\x18\x02\x20\x01(\x0b2&.google.bigtable.admin.v2.Colum\ + nFamilyR\x05value:\x028\x01\"I\n\x14TimestampGranularity\x12%\n!TIMESTAM\ + P_GRANULARITY_UNSPECIFIED\x10\0\x12\n\n\x06MILLIS\x10\x01\"\\\n\x04View\ + \x12\x14\n\x10VIEW_UNSPECIFIED\x10\0\x12\r\n\tNAME_ONLY\x10\x01\x12\x0f\ + \n\x0bSCHEMA_VIEW\x10\x02\x12\x14\n\x10REPLICATION_VIEW\x10\x03\x12\x08\ + \n\x04FULL\x10\x04\"I\n\x0cColumnFamily\x129\n\x07gc_rule\x18\x01\x20\ + \x01(\x0b2\x20.google.bigtable.admin.v2.GcRuleR\x06gcRule\"\x90\x03\n\ + \x06GcRule\x12*\n\x10max_num_versions\x18\x01\x20\x01(\x05H\0R\x0emaxNum\ + Versions\x124\n\x07max_age\x18\x02\x20\x01(\x0b2\x19.google.protobuf.Dur\ + ationH\0R\x06maxAge\x12S\n\x0cintersection\x18\x03\x20\x01(\x0b2-.google\ + .bigtable.admin.v2.GcRule.IntersectionH\0R\x0cintersection\x12>\n\x05uni\ + on\x18\x04\x20\x01(\x0b2&.google.bigtable.admin.v2.GcRule.UnionH\0R\x05u\ + nion\x1aF\n\x0cIntersection\x126\n\x05rules\x18\x01\x20\x03(\x0b2\x20.go\ + ogle.bigtable.admin.v2.GcRuleR\x05rules\x1a?\n\x05Union\x126\n\x05rules\ + \x18\x01\x20\x03(\x0b2\x20.google.bigtable.admin.v2.GcRuleR\x05rulesB\ + \x06\n\x04rule\"\x9d\x03\n\x08Snapshot\x12\x12\n\x04name\x18\x01\x20\x01\ + (\tR\x04name\x12B\n\x0csource_table\x18\x02\x20\x01(\x0b2\x1f.google.big\ + table.admin.v2.TableR\x0bsourceTable\x12&\n\x0fdata_size_bytes\x18\x03\ + \x20\x01(\x03R\rdataSizeBytes\x12;\n\x0bcreate_time\x18\x04\x20\x01(\x0b\ + 2\x1a.google.protobuf.TimestampR\ncreateTime\x12;\n\x0bdelete_time\x18\ + \x05\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ndeleteTime\x12>\n\x05\ + state\x18\x06\x20\x01(\x0e2(.google.bigtable.admin.v2.Snapshot.StateR\ + \x05state\x12\x20\n\x0bdescription\x18\x07\x20\x01(\tR\x0bdescription\"5\ + \n\x05State\x12\x13\n\x0fSTATE_NOT_KNOWN\x10\0\x12\t\n\x05READY\x10\x01\ + \x12\x0c\n\x08CREATING\x10\x02B\xad\x01\n\x1ccom.google.bigtable.admin.v\ + 2B\nTableProtoP\x01Z=google.golang.org/genproto/googleapis/bigtable/admi\ + n/v2;admin\xaa\x02\x1eGoogle.Cloud.Bigtable.Admin.V2\xca\x02\x1eGoogle\\\ + Cloud\\Bigtable\\Admin\\V2J\xb4A\n\x07\x12\x05\x0f\0\xdc\x01\x01\n\xbe\ + \x04\n\x01\x0c\x12\x03\x0f\0\x122\xb3\x04\x20Copyright\x202018\x20Google\ + \x20LLC.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Versio\ + n\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\ + \x20file\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20Y\ + ou\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\ + \x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\ + \x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20w\ + riting,\x20software\n\x20distributed\x20under\x20the\x20License\x20is\ + \x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WA\ + RRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\ + \x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\ + \x20language\x20governing\x20permissions\x20and\n\x20limitations\x20unde\ + r\x20the\x20License.\n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\t\n\x02\x03\0\ + \x12\x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\x14\0(\n\t\n\x02\x03\x02\x12\ + \x03\x15\0)\n\x08\n\x01\x08\x12\x03\x17\0;\n\t\n\x02\x08%\x12\x03\x17\0;\ + \n\x08\n\x01\x08\x12\x03\x18\0T\n\t\n\x02\x08\x0b\x12\x03\x18\0T\n\x08\n\ + \x01\x08\x12\x03\x19\0\"\n\t\n\x02\x08\n\x12\x03\x19\0\"\n\x08\n\x01\x08\ + \x12\x03\x1a\0+\n\t\n\x02\x08\x08\x12\x03\x1a\0+\n\x08\n\x01\x08\x12\x03\ + \x1b\05\n\t\n\x02\x08\x01\x12\x03\x1b\05\n\x08\n\x01\x08\x12\x03\x1c\0<\ + \n\t\n\x02\x08)\x12\x03\x1c\0<\n\x90\x01\n\x02\x04\0\x12\x04!\0x\x01\x1a\ + \x83\x01\x20A\x20collection\x20of\x20user\x20data\x20indexed\x20by\x20ro\ + w,\x20column,\x20and\x20timestamp.\n\x20Each\x20table\x20is\x20served\ + \x20using\x20the\x20resources\x20of\x20its\x20parent\x20cluster.\n\n\n\n\ + \x03\x04\0\x01\x12\x03!\x08\r\nD\n\x04\x04\0\x03\0\x12\x04#\x02?\x03\x1a\ + 6\x20The\x20state\x20of\x20a\x20table's\x20data\x20in\x20a\x20particular\ + \x20cluster.\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03#\n\x16\n+\n\x06\x04\0\ + \x03\0\x04\0\x12\x04%\x04:\x05\x1a\x1b\x20Table\x20replication\x20states\ + .\n\n\x0e\n\x07\x04\0\x03\0\x04\0\x01\x12\x03%\t\x19\nQ\n\x08\x04\0\x03\ + \0\x04\0\x02\0\x12\x03'\x06\x1a\x1a@\x20The\x20replication\x20state\x20o\ + f\x20the\x20table\x20is\x20unknown\x20in\x20this\x20cluster.\n\n\x10\n\t\ + \x04\0\x03\0\x04\0\x02\0\x01\x12\x03'\x06\x15\n\x10\n\t\x04\0\x03\0\x04\ + \0\x02\0\x02\x12\x03'\x18\x19\n\xda\x01\n\x08\x04\0\x03\0\x04\0\x02\x01\ + \x12\x03,\x06\x17\x1a\xc8\x01\x20The\x20cluster\x20was\x20recently\x20cr\ + eated,\x20and\x20the\x20table\x20must\x20finish\x20copying\n\x20over\x20\ + pre-existing\x20data\x20from\x20other\x20clusters\x20before\x20it\x20can\ + \x20begin\n\x20receiving\x20live\x20replication\x20updates\x20and\x20ser\ + ving\x20Data\x20API\x20requests.\n\n\x10\n\t\x04\0\x03\0\x04\0\x02\x01\ + \x01\x12\x03,\x06\x12\n\x10\n\t\x04\0\x03\0\x04\0\x02\x01\x02\x12\x03,\ + \x15\x16\n\x85\x01\n\x08\x04\0\x03\0\x04\0\x02\x02\x12\x030\x06\x1e\x1at\ + \x20The\x20table\x20is\x20temporarily\x20unable\x20to\x20serve\x20Data\ + \x20API\x20requests\x20from\x20this\n\x20cluster\x20due\x20to\x20planned\ + \x20internal\x20maintenance.\n\n\x10\n\t\x04\0\x03\0\x04\0\x02\x02\x01\ + \x12\x030\x06\x19\n\x10\n\t\x04\0\x03\0\x04\0\x02\x02\x02\x12\x030\x1c\ + \x1d\n\x8b\x01\n\x08\x04\0\x03\0\x04\0\x02\x03\x12\x034\x06\x20\x1az\x20\ + The\x20table\x20is\x20temporarily\x20unable\x20to\x20serve\x20Data\x20AP\ + I\x20requests\x20from\x20this\n\x20cluster\x20due\x20to\x20unplanned\x20\ + or\x20emergency\x20maintenance.\n\n\x10\n\t\x04\0\x03\0\x04\0\x02\x03\ + \x01\x12\x034\x06\x1b\n\x10\n\t\x04\0\x03\0\x04\0\x02\x03\x02\x12\x034\ + \x1e\x1f\n\xba\x01\n\x08\x04\0\x03\0\x04\0\x02\x04\x12\x039\x06\x10\x1a\ + \xa8\x01\x20The\x20table\x20can\x20serve\x20Data\x20API\x20requests\x20f\ + rom\x20this\x20cluster.\x20Depending\x20on\n\x20replication\x20delay,\ + \x20reads\x20may\x20not\x20immediately\x20reflect\x20the\x20state\x20of\ + \x20the\n\x20table\x20in\x20other\x20clusters.\n\n\x10\n\t\x04\0\x03\0\ + \x04\0\x02\x04\x01\x12\x039\x06\x0b\n\x10\n\t\x04\0\x03\0\x04\0\x02\x04\ + \x02\x12\x039\x0e\x0f\nX\n\x06\x04\0\x03\0\x02\0\x12\x03>\x04+\x1aI\x20(\ + `OutputOnly`)\n\x20The\x20state\x20of\x20replication\x20for\x20the\x20ta\ + ble\x20in\x20this\x20cluster.\n\n\x0f\n\x07\x04\0\x03\0\x02\0\x04\x12\ + \x04>\x04:\x05\n\x0e\n\x07\x04\0\x03\0\x02\0\x06\x12\x03>\x04\x14\n\x0e\ + \n\x07\x04\0\x03\0\x02\0\x01\x12\x03>\x15&\n\x0e\n\x07\x04\0\x03\0\x02\0\ + \x03\x12\x03>)*\nk\n\x04\x04\0\x04\0\x12\x04C\x02J\x03\x1a]\x20Possible\ + \x20timestamp\x20granularities\x20to\x20use\x20when\x20keeping\x20multip\ + le\x20versions\n\x20of\x20data\x20in\x20a\x20table.\n\n\x0c\n\x05\x04\0\ + \x04\0\x01\x12\x03C\x07\x1b\n\x8c\x01\n\x06\x04\0\x04\0\x02\0\x12\x03F\ + \x04*\x1a}\x20The\x20user\x20did\x20not\x20specify\x20a\x20granularity.\ + \x20Should\x20not\x20be\x20returned.\n\x20When\x20specified\x20during\ + \x20table\x20creation,\x20MILLIS\x20will\x20be\x20used.\n\n\x0e\n\x07\ + \x04\0\x04\0\x02\0\x01\x12\x03F\x04%\n\x0e\n\x07\x04\0\x04\0\x02\0\x02\ + \x12\x03F()\nH\n\x06\x04\0\x04\0\x02\x01\x12\x03I\x04\x0f\x1a9\x20The\ + \x20table\x20keeps\x20data\x20versioned\x20at\x20a\x20granularity\x20of\ + \x201ms.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\x12\x03I\x04\n\n\x0e\n\ + \x07\x04\0\x04\0\x02\x01\x02\x12\x03I\r\x0e\n5\n\x04\x04\0\x04\x01\x12\ + \x04M\x02]\x03\x1a'\x20Defines\x20a\x20view\x20over\x20a\x20table's\x20f\ + ields.\n\n\x0c\n\x05\x04\0\x04\x01\x01\x12\x03M\x07\x0b\nT\n\x06\x04\0\ + \x04\x01\x02\0\x12\x03O\x04\x19\x1aE\x20Uses\x20the\x20default\x20view\ + \x20for\x20each\x20method\x20as\x20documented\x20in\x20its\x20request.\n\ + \n\x0e\n\x07\x04\0\x04\x01\x02\0\x01\x12\x03O\x04\x14\n\x0e\n\x07\x04\0\ + \x04\x01\x02\0\x02\x12\x03O\x17\x18\n'\n\x06\x04\0\x04\x01\x02\x01\x12\ + \x03R\x04\x12\x1a\x18\x20Only\x20populates\x20`name`.\n\n\x0e\n\x07\x04\ + \0\x04\x01\x02\x01\x01\x12\x03R\x04\r\n\x0e\n\x07\x04\0\x04\x01\x02\x01\ + \x02\x12\x03R\x10\x11\nP\n\x06\x04\0\x04\x01\x02\x02\x12\x03U\x04\x14\ + \x1aA\x20Only\x20populates\x20`name`\x20and\x20fields\x20related\x20to\ + \x20the\x20table's\x20schema.\n\n\x0e\n\x07\x04\0\x04\x01\x02\x02\x01\ + \x12\x03U\x04\x0f\n\x0e\n\x07\x04\0\x04\x01\x02\x02\x02\x12\x03U\x12\x13\ + \n\\\n\x06\x04\0\x04\x01\x02\x03\x12\x03Y\x04\x19\x1aM\x20Only\x20popula\ + tes\x20`name`\x20and\x20fields\x20related\x20to\x20the\x20table's\n\x20r\ + eplication\x20state.\n\n\x0e\n\x07\x04\0\x04\x01\x02\x03\x01\x12\x03Y\ + \x04\x14\n\x0e\n\x07\x04\0\x04\x01\x02\x03\x02\x12\x03Y\x17\x18\n&\n\x06\ + \x04\0\x04\x01\x02\x04\x12\x03\\\x04\r\x1a\x17\x20Populates\x20all\x20fi\ + elds.\n\n\x0e\n\x07\x04\0\x04\x01\x02\x04\x01\x12\x03\\\x04\x08\n\x0e\n\ + \x07\x04\0\x04\x01\x02\x04\x02\x12\x03\\\x0b\x0c\n\xe2\x01\n\x04\x04\0\ + \x02\0\x12\x03c\x02\x12\x1a\xd4\x01\x20(`OutputOnly`)\n\x20The\x20unique\ + \x20name\x20of\x20the\x20table.\x20Values\x20are\x20of\x20the\x20form\n\ + \x20`projects//instances//tables/[_a-zA-Z0-9][-_.a-zA\ + -Z0-9]*`.\n\x20Views:\x20`NAME_ONLY`,\x20`SCHEMA_VIEW`,\x20`REPLICATION_\ + VIEW`,\x20`FULL`\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04c\x02]\x03\n\x0c\n\ + \x05\x04\0\x02\0\x05\x12\x03c\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\ + \x03c\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03c\x10\x11\n\xc7\x02\n\x04\ + \x04\0\x02\x01\x12\x03k\x02/\x1a\xb9\x02\x20(`OutputOnly`)\n\x20Map\x20f\ + rom\x20cluster\x20ID\x20to\x20per-cluster\x20table\x20state.\n\x20If\x20\ + it\x20could\x20not\x20be\x20determined\x20whether\x20or\x20not\x20the\ + \x20table\x20has\x20data\x20in\x20a\n\x20particular\x20cluster\x20(for\ + \x20example,\x20if\x20its\x20zone\x20is\x20unavailable),\x20then\n\x20th\ + ere\x20will\x20be\x20an\x20entry\x20for\x20the\x20cluster\x20with\x20UNK\ + NOWN\x20`replication_status`.\n\x20Views:\x20`REPLICATION_VIEW`,\x20`FUL\ + L`\n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04k\x02c\x12\n\x0c\n\x05\x04\0\x02\ + \x01\x06\x12\x03k\x02\x1b\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03k\x1c*\n\ + \x0c\n\x05\x04\0\x02\x01\x03\x12\x03k-.\n\x89\x01\n\x04\x04\0\x02\x02\ + \x12\x03p\x020\x1a|\x20(`CreationOnly`)\n\x20The\x20column\x20families\ + \x20configured\x20for\x20this\x20table,\x20mapped\x20by\x20column\x20fam\ + ily\x20ID.\n\x20Views:\x20`SCHEMA_VIEW`,\x20`FULL`\n\n\r\n\x05\x04\0\x02\ + \x02\x04\x12\x04p\x02k/\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03p\x02\x1b\n\ + \x0c\n\x05\x04\0\x02\x02\x01\x12\x03p\x1c+\n\x0c\n\x05\x04\0\x02\x02\x03\ + \x12\x03p./\n\x8d\x02\n\x04\x04\0\x02\x03\x12\x03w\x02'\x1a\xff\x01\x20(\ + `CreationOnly`)\n\x20The\x20granularity\x20(i.e.\x20`MILLIS`)\x20at\x20w\ + hich\x20timestamps\x20are\x20stored\x20in\n\x20this\x20table.\x20Timesta\ + mps\x20not\x20matching\x20the\x20granularity\x20will\x20be\x20rejected.\ + \n\x20If\x20unspecified\x20at\x20creation\x20time,\x20the\x20value\x20wi\ + ll\x20be\x20set\x20to\x20`MILLIS`.\n\x20Views:\x20`SCHEMA_VIEW`,\x20`FUL\ + L`\n\n\r\n\x05\x04\0\x02\x03\x04\x12\x04w\x02p0\n\x0c\n\x05\x04\0\x02\ + \x03\x06\x12\x03w\x02\x16\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03w\x17\"\n\ + \x0c\n\x05\x04\0\x02\x03\x03\x12\x03w%&\nR\n\x02\x04\x01\x12\x05{\0\x83\ + \x01\x01\x1aE\x20A\x20set\x20of\x20columns\x20within\x20a\x20table\x20wh\ + ich\x20share\x20a\x20common\x20configuration.\n\n\n\n\x03\x04\x01\x01\ + \x12\x03{\x08\x14\n\x9e\x02\n\x04\x04\x01\x02\0\x12\x04\x82\x01\x02\x15\ + \x1a\x8f\x02\x20Garbage\x20collection\x20rule\x20specified\x20as\x20a\ + \x20protobuf.\n\x20Must\x20serialize\x20to\x20at\x20most\x20500\x20bytes\ + .\n\n\x20NOTE:\x20Garbage\x20collection\x20executes\x20opportunistically\ + \x20in\x20the\x20background,\x20and\n\x20so\x20it's\x20possible\x20for\ + \x20reads\x20to\x20return\x20a\x20cell\x20even\x20if\x20it\x20matches\ + \x20the\x20active\n\x20GC\x20expression\x20for\x20its\x20family.\n\n\x0e\ + \n\x05\x04\x01\x02\0\x04\x12\x05\x82\x01\x02{\x16\n\r\n\x05\x04\x01\x02\ + \0\x06\x12\x04\x82\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\x82\ + \x01\t\x10\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\x82\x01\x13\x14\nU\n\x02\ + \x04\x02\x12\x06\x86\x01\0\xa3\x01\x01\x1aG\x20Rule\x20for\x20determinin\ + g\x20which\x20cells\x20to\x20delete\x20during\x20garbage\x20collection.\ + \n\n\x0b\n\x03\x04\x02\x01\x12\x04\x86\x01\x08\x0e\nO\n\x04\x04\x02\x03\ + \0\x12\x06\x88\x01\x02\x8b\x01\x03\x1a?\x20A\x20GcRule\x20which\x20delet\ + es\x20cells\x20matching\x20all\x20of\x20the\x20given\x20rules.\n\n\r\n\ + \x05\x04\x02\x03\0\x01\x12\x04\x88\x01\n\x16\nW\n\x06\x04\x02\x03\0\x02\ + \0\x12\x04\x8a\x01\x04\x1e\x1aG\x20Only\x20delete\x20cells\x20which\x20w\ + ould\x20be\x20deleted\x20by\x20every\x20element\x20of\x20`rules`.\n\n\ + \x0f\n\x07\x04\x02\x03\0\x02\0\x04\x12\x04\x8a\x01\x04\x0c\n\x0f\n\x07\ + \x04\x02\x03\0\x02\0\x06\x12\x04\x8a\x01\r\x13\n\x0f\n\x07\x04\x02\x03\0\ + \x02\0\x01\x12\x04\x8a\x01\x14\x19\n\x0f\n\x07\x04\x02\x03\0\x02\0\x03\ + \x12\x04\x8a\x01\x1c\x1d\nO\n\x04\x04\x02\x03\x01\x12\x06\x8e\x01\x02\ + \x91\x01\x03\x1a?\x20A\x20GcRule\x20which\x20deletes\x20cells\x20matchin\ + g\x20any\x20of\x20the\x20given\x20rules.\n\n\r\n\x05\x04\x02\x03\x01\x01\ + \x12\x04\x8e\x01\n\x0f\nP\n\x06\x04\x02\x03\x01\x02\0\x12\x04\x90\x01\ + \x04\x1e\x1a@\x20Delete\x20cells\x20which\x20would\x20be\x20deleted\x20b\ + y\x20any\x20element\x20of\x20`rules`.\n\n\x0f\n\x07\x04\x02\x03\x01\x02\ + \0\x04\x12\x04\x90\x01\x04\x0c\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x06\x12\ + \x04\x90\x01\r\x13\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x01\x12\x04\x90\x01\ + \x14\x19\n\x0f\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x04\x90\x01\x1c\x1d\n\ + +\n\x04\x04\x02\x08\0\x12\x06\x94\x01\x02\xa2\x01\x03\x1a\x1b\x20Garbage\ + \x20collection\x20rules.\n\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\x94\x01\ + \x08\x0c\nF\n\x04\x04\x02\x02\0\x12\x04\x96\x01\x04\x1f\x1a8\x20Delete\ + \x20all\x20cells\x20in\x20a\x20column\x20except\x20the\x20most\x20recent\ + \x20N.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\x96\x01\x04\t\n\r\n\x05\x04\ + \x02\x02\0\x01\x12\x04\x96\x01\n\x1a\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\ + \x96\x01\x1d\x1e\n\xa0\x01\n\x04\x04\x02\x02\x01\x12\x04\x9b\x01\x04)\ + \x1a\x91\x01\x20Delete\x20cells\x20in\x20a\x20column\x20older\x20than\ + \x20the\x20given\x20age.\n\x20Values\x20must\x20be\x20at\x20least\x20one\ + \x20millisecond,\x20and\x20will\x20be\x20truncated\x20to\n\x20microsecon\ + d\x20granularity.\n\n\r\n\x05\x04\x02\x02\x01\x06\x12\x04\x9b\x01\x04\ + \x1c\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\x9b\x01\x1d$\n\r\n\x05\x04\ + \x02\x02\x01\x03\x12\x04\x9b\x01'(\nH\n\x04\x04\x02\x02\x02\x12\x04\x9e\ + \x01\x04\"\x1a:\x20Delete\x20cells\x20that\x20would\x20be\x20deleted\x20\ + by\x20every\x20nested\x20rule.\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\ + \x9e\x01\x04\x10\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\x9e\x01\x11\x1d\n\ + \r\n\x05\x04\x02\x02\x02\x03\x12\x04\x9e\x01\x20!\nF\n\x04\x04\x02\x02\ + \x03\x12\x04\xa1\x01\x04\x14\x1a8\x20Delete\x20cells\x20that\x20would\ + \x20be\x20deleted\x20by\x20any\x20nested\x20rule.\n\n\r\n\x05\x04\x02\ + \x02\x03\x06\x12\x04\xa1\x01\x04\t\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\ + \xa1\x01\n\x0f\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\xa1\x01\x12\x13\n\ + \xc8\x03\n\x02\x04\x03\x12\x06\xac\x01\0\xdc\x01\x01\x1a\xb9\x03\x20A\ + \x20snapshot\x20of\x20a\x20table\x20at\x20a\x20particular\x20time.\x20A\ + \x20snapshot\x20can\x20be\x20used\x20as\x20a\n\x20checkpoint\x20for\x20d\ + ata\x20restoration\x20or\x20a\x20data\x20source\x20for\x20a\x20new\x20ta\ + ble.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20o\ + f\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\ + \x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20custome\ + rs.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-inc\ + ompatible\x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20product\ + ion\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20d\ + eprecation\x20policy.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xac\x01\x08\x10\ + \n0\n\x04\x04\x03\x04\0\x12\x06\xae\x01\x02\xb9\x01\x03\x1a\x20\x20Possi\ + ble\x20states\x20of\x20a\x20snapshot.\n\n\r\n\x05\x04\x03\x04\0\x01\x12\ + \x04\xae\x01\x07\x0c\nD\n\x06\x04\x03\x04\0\x02\0\x12\x04\xb0\x01\x04\ + \x18\x1a4\x20The\x20state\x20of\x20the\x20snapshot\x20could\x20not\x20be\ + \x20determined.\n\n\x0f\n\x07\x04\x03\x04\0\x02\0\x01\x12\x04\xb0\x01\ + \x04\x13\n\x0f\n\x07\x04\x03\x04\0\x02\0\x02\x12\x04\xb0\x01\x16\x17\nX\ + \n\x06\x04\x03\x04\0\x02\x01\x12\x04\xb3\x01\x04\x0e\x1aH\x20The\x20snap\ + shot\x20has\x20been\x20successfully\x20created\x20and\x20can\x20serve\ + \x20all\x20requests.\n\n\x0f\n\x07\x04\x03\x04\0\x02\x01\x01\x12\x04\xb3\ + \x01\x04\t\n\x0f\n\x07\x04\x03\x04\0\x02\x01\x02\x12\x04\xb3\x01\x0c\r\n\ + \xc4\x01\n\x06\x04\x03\x04\0\x02\x02\x12\x04\xb8\x01\x04\x11\x1a\xb3\x01\ + \x20The\x20snapshot\x20is\x20currently\x20being\x20created,\x20and\x20ma\ + y\x20be\x20destroyed\x20if\x20the\n\x20creation\x20process\x20encounters\ + \x20an\x20error.\x20A\x20snapshot\x20may\x20not\x20be\x20restored\x20to\ + \x20a\n\x20table\x20while\x20it\x20is\x20being\x20created.\n\n\x0f\n\x07\ + \x04\x03\x04\0\x02\x02\x01\x12\x04\xb8\x01\x04\x0c\n\x0f\n\x07\x04\x03\ + \x04\0\x02\x02\x02\x12\x04\xb8\x01\x0f\x10\n\xad\x01\n\x04\x04\x03\x02\0\ + \x12\x04\xbf\x01\x02\x12\x1a\x9e\x01\x20(`OutputOnly`)\n\x20The\x20uniqu\ + e\x20name\x20of\x20the\x20snapshot.\n\x20Values\x20are\x20of\x20the\x20f\ + orm\n\x20`projects//instances//clusters//sna\ + pshots/`.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xbf\x01\x02\ + \xb9\x01\x03\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\xbf\x01\x02\x08\n\r\n\ + \x05\x04\x03\x02\0\x01\x12\x04\xbf\x01\t\r\n\r\n\x05\x04\x03\x02\0\x03\ + \x12\x04\xbf\x01\x10\x11\nT\n\x04\x04\x03\x02\x01\x12\x04\xc3\x01\x02\ + \x19\x1aF\x20(`OutputOnly`)\n\x20The\x20source\x20table\x20at\x20the\x20\ + time\x20the\x20snapshot\x20was\x20taken.\n\n\x0f\n\x05\x04\x03\x02\x01\ + \x04\x12\x06\xc3\x01\x02\xbf\x01\x12\n\r\n\x05\x04\x03\x02\x01\x06\x12\ + \x04\xc3\x01\x02\x07\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\xc3\x01\x08\ + \x14\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xc3\x01\x17\x18\n\xf6\x01\n\ + \x04\x04\x03\x02\x02\x12\x04\xc9\x01\x02\x1c\x1a\xe7\x01\x20(`OutputOnly\ + `)\n\x20The\x20size\x20of\x20the\x20data\x20in\x20the\x20source\x20table\ + \x20at\x20the\x20time\x20the\x20snapshot\x20was\n\x20taken.\x20In\x20som\ + e\x20cases,\x20this\x20value\x20may\x20be\x20computed\x20asynchronously\ + \x20via\x20a\n\x20background\x20process\x20and\x20a\x20placeholder\x20of\ + \x200\x20will\x20be\x20used\x20in\x20the\x20meantime.\n\n\x0f\n\x05\x04\ + \x03\x02\x02\x04\x12\x06\xc9\x01\x02\xc3\x01\x19\n\r\n\x05\x04\x03\x02\ + \x02\x05\x12\x04\xc9\x01\x02\x07\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\ + \xc9\x01\x08\x17\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xc9\x01\x1a\x1b\n\ + F\n\x04\x04\x03\x02\x03\x12\x04\xcd\x01\x02,\x1a8\x20(`OutputOnly`)\n\ + \x20The\x20time\x20when\x20the\x20snapshot\x20is\x20created.\n\n\x0f\n\ + \x05\x04\x03\x02\x03\x04\x12\x06\xcd\x01\x02\xc9\x01\x1c\n\r\n\x05\x04\ + \x03\x02\x03\x06\x12\x04\xcd\x01\x02\x1b\n\r\n\x05\x04\x03\x02\x03\x01\ + \x12\x04\xcd\x01\x1c'\n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\xcd\x01*+\n\ + \xda\x01\n\x04\x04\x03\x02\x04\x12\x04\xd3\x01\x02,\x1a\xcb\x01\x20(`Out\ + putOnly`)\n\x20The\x20time\x20when\x20the\x20snapshot\x20will\x20be\x20d\ + eleted.\x20The\x20maximum\x20amount\x20of\x20time\x20a\n\x20snapshot\x20\ + can\x20stay\x20active\x20is\x20365\x20days.\x20If\x20'ttl'\x20is\x20not\ + \x20specified,\n\x20the\x20default\x20maximum\x20of\x20365\x20days\x20wi\ + ll\x20be\x20used.\n\n\x0f\n\x05\x04\x03\x02\x04\x04\x12\x06\xd3\x01\x02\ + \xcd\x01,\n\r\n\x05\x04\x03\x02\x04\x06\x12\x04\xd3\x01\x02\x1b\n\r\n\ + \x05\x04\x03\x02\x04\x01\x12\x04\xd3\x01\x1c'\n\r\n\x05\x04\x03\x02\x04\ + \x03\x12\x04\xd3\x01*+\nB\n\x04\x04\x03\x02\x05\x12\x04\xd7\x01\x02\x12\ + \x1a4\x20(`OutputOnly`)\n\x20The\x20current\x20state\x20of\x20the\x20sna\ + pshot.\n\n\x0f\n\x05\x04\x03\x02\x05\x04\x12\x06\xd7\x01\x02\xd3\x01,\n\ + \r\n\x05\x04\x03\x02\x05\x06\x12\x04\xd7\x01\x02\x07\n\r\n\x05\x04\x03\ + \x02\x05\x01\x12\x04\xd7\x01\x08\r\n\r\n\x05\x04\x03\x02\x05\x03\x12\x04\ + \xd7\x01\x10\x11\n<\n\x04\x04\x03\x02\x06\x12\x04\xdb\x01\x02\x19\x1a.\ + \x20(`OutputOnly`)\n\x20Description\x20of\x20the\x20snapshot.\n\n\x0f\n\ + \x05\x04\x03\x02\x06\x04\x12\x06\xdb\x01\x02\xd7\x01\x12\n\r\n\x05\x04\ + \x03\x02\x06\x05\x12\x04\xdb\x01\x02\x08\n\r\n\x05\x04\x03\x02\x06\x01\ + \x12\x04\xdb\x01\t\x14\n\r\n\x05\x04\x03\x02\x06\x03\x12\x04\xdb\x01\x17\ + \x18b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/mod.rs new file mode 100644 index 00000000..7a6f59ba --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/mod.rs @@ -0,0 +1,3 @@ +pub mod admin; +pub mod v1; +pub mod v2; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_data.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_data.rs new file mode 100644 index 00000000..73824ed1 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_data.rs @@ -0,0 +1,6797 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/v1/bigtable_data.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Row { + // message fields + pub key: ::std::vec::Vec, + pub families: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Row { + fn default() -> &'a Row { + ::default_instance() + } +} + +impl Row { + pub fn new() -> Row { + ::std::default::Default::default() + } + + // bytes key = 1; + + + pub fn get_key(&self) -> &[u8] { + &self.key + } + pub fn clear_key(&mut self) { + self.key.clear(); + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::vec::Vec) { + self.key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.key + } + + // Take field + pub fn take_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.Family families = 2; + + + pub fn get_families(&self) -> &[Family] { + &self.families + } + pub fn clear_families(&mut self) { + self.families.clear(); + } + + // Param is passed by value, moved + pub fn set_families(&mut self, v: ::protobuf::RepeatedField) { + self.families = v; + } + + // Mutable pointer to the field. + pub fn mut_families(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.families + } + + // Take field + pub fn take_families(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.families, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Row { + fn is_initialized(&self) -> bool { + for v in &self.families { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.families)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.key); + } + for value in &self.families { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.key.is_empty() { + os.write_bytes(1, &self.key)?; + } + for v in &self.families { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Row { + Row::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "key", + |m: &Row| { &m.key }, + |m: &mut Row| { &mut m.key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "families", + |m: &Row| { &m.families }, + |m: &mut Row| { &mut m.families }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Row", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Row { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Row, + }; + unsafe { + instance.get(Row::new) + } + } +} + +impl ::protobuf::Clear for Row { + fn clear(&mut self) { + self.key.clear(); + self.families.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Row { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Row { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Family { + // message fields + pub name: ::std::string::String, + pub columns: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Family { + fn default() -> &'a Family { + ::default_instance() + } +} + +impl Family { + pub fn new() -> Family { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.bigtable.v1.Column columns = 2; + + + pub fn get_columns(&self) -> &[Column] { + &self.columns + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + + // Param is passed by value, moved + pub fn set_columns(&mut self, v: ::protobuf::RepeatedField) { + self.columns = v; + } + + // Mutable pointer to the field. + pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.columns + } + + // Take field + pub fn take_columns(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Family { + fn is_initialized(&self) -> bool { + for v in &self.columns { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.columns)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.columns { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.columns { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Family { + Family::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Family| { &m.name }, + |m: &mut Family| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "columns", + |m: &Family| { &m.columns }, + |m: &mut Family| { &mut m.columns }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Family", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Family { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Family, + }; + unsafe { + instance.get(Family::new) + } + } +} + +impl ::protobuf::Clear for Family { + fn clear(&mut self) { + self.name.clear(); + self.columns.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Family { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Family { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Column { + // message fields + pub qualifier: ::std::vec::Vec, + pub cells: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Column { + fn default() -> &'a Column { + ::default_instance() + } +} + +impl Column { + pub fn new() -> Column { + ::std::default::Default::default() + } + + // bytes qualifier = 1; + + + pub fn get_qualifier(&self) -> &[u8] { + &self.qualifier + } + pub fn clear_qualifier(&mut self) { + self.qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_qualifier(&mut self, v: ::std::vec::Vec) { + self.qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.qualifier + } + + // Take field + pub fn take_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.qualifier, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.Cell cells = 2; + + + pub fn get_cells(&self) -> &[Cell] { + &self.cells + } + pub fn clear_cells(&mut self) { + self.cells.clear(); + } + + // Param is passed by value, moved + pub fn set_cells(&mut self, v: ::protobuf::RepeatedField) { + self.cells = v; + } + + // Mutable pointer to the field. + pub fn mut_cells(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.cells + } + + // Take field + pub fn take_cells(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.cells, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Column { + fn is_initialized(&self) -> bool { + for v in &self.cells { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.qualifier)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.cells)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.qualifier); + } + for value in &self.cells { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.qualifier.is_empty() { + os.write_bytes(1, &self.qualifier)?; + } + for v in &self.cells { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Column { + Column::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "qualifier", + |m: &Column| { &m.qualifier }, + |m: &mut Column| { &mut m.qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "cells", + |m: &Column| { &m.cells }, + |m: &mut Column| { &mut m.cells }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Column", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Column { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Column, + }; + unsafe { + instance.get(Column::new) + } + } +} + +impl ::protobuf::Clear for Column { + fn clear(&mut self) { + self.qualifier.clear(); + self.cells.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Column { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Column { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Cell { + // message fields + pub timestamp_micros: i64, + pub value: ::std::vec::Vec, + pub labels: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Cell { + fn default() -> &'a Cell { + ::default_instance() + } +} + +impl Cell { + pub fn new() -> Cell { + ::std::default::Default::default() + } + + // int64 timestamp_micros = 1; + + + pub fn get_timestamp_micros(&self) -> i64 { + self.timestamp_micros + } + pub fn clear_timestamp_micros(&mut self) { + self.timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_timestamp_micros(&mut self, v: i64) { + self.timestamp_micros = v; + } + + // bytes value = 2; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } + + // repeated string labels = 3; + + + pub fn get_labels(&self) -> &[::std::string::String] { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Cell { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.timestamp_micros = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(1, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.value); + } + for value in &self.labels { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.timestamp_micros != 0 { + os.write_int64(1, self.timestamp_micros)?; + } + if !self.value.is_empty() { + os.write_bytes(2, &self.value)?; + } + for v in &self.labels { + os.write_string(3, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Cell { + Cell::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "timestamp_micros", + |m: &Cell| { &m.timestamp_micros }, + |m: &mut Cell| { &mut m.timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &Cell| { &m.value }, + |m: &mut Cell| { &mut m.value }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Cell| { &m.labels }, + |m: &mut Cell| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Cell", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Cell { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Cell, + }; + unsafe { + instance.get(Cell::new) + } + } +} + +impl ::protobuf::Clear for Cell { + fn clear(&mut self) { + self.timestamp_micros = 0; + self.value.clear(); + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Cell { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Cell { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowRange { + // message fields + pub start_key: ::std::vec::Vec, + pub end_key: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowRange { + fn default() -> &'a RowRange { + ::default_instance() + } +} + +impl RowRange { + pub fn new() -> RowRange { + ::std::default::Default::default() + } + + // bytes start_key = 2; + + + pub fn get_start_key(&self) -> &[u8] { + &self.start_key + } + pub fn clear_start_key(&mut self) { + self.start_key.clear(); + } + + // Param is passed by value, moved + pub fn set_start_key(&mut self, v: ::std::vec::Vec) { + self.start_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_start_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.start_key + } + + // Take field + pub fn take_start_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.start_key, ::std::vec::Vec::new()) + } + + // bytes end_key = 3; + + + pub fn get_end_key(&self) -> &[u8] { + &self.end_key + } + pub fn clear_end_key(&mut self) { + self.end_key.clear(); + } + + // Param is passed by value, moved + pub fn set_end_key(&mut self, v: ::std::vec::Vec) { + self.end_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_end_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.end_key + } + + // Take field + pub fn take_end_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.end_key, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for RowRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.start_key)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.end_key)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.start_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.start_key); + } + if !self.end_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(3, &self.end_key); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.start_key.is_empty() { + os.write_bytes(2, &self.start_key)?; + } + if !self.end_key.is_empty() { + os.write_bytes(3, &self.end_key)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowRange { + RowRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "start_key", + |m: &RowRange| { &m.start_key }, + |m: &mut RowRange| { &mut m.start_key }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "end_key", + |m: &RowRange| { &m.end_key }, + |m: &mut RowRange| { &mut m.end_key }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowRange, + }; + unsafe { + instance.get(RowRange::new) + } + } +} + +impl ::protobuf::Clear for RowRange { + fn clear(&mut self) { + self.start_key.clear(); + self.end_key.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowSet { + // message fields + pub row_keys: ::protobuf::RepeatedField<::std::vec::Vec>, + pub row_ranges: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowSet { + fn default() -> &'a RowSet { + ::default_instance() + } +} + +impl RowSet { + pub fn new() -> RowSet { + ::std::default::Default::default() + } + + // repeated bytes row_keys = 1; + + + pub fn get_row_keys(&self) -> &[::std::vec::Vec] { + &self.row_keys + } + pub fn clear_row_keys(&mut self) { + self.row_keys.clear(); + } + + // Param is passed by value, moved + pub fn set_row_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec>) { + self.row_keys = v; + } + + // Mutable pointer to the field. + pub fn mut_row_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec> { + &mut self.row_keys + } + + // Take field + pub fn take_row_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec> { + ::std::mem::replace(&mut self.row_keys, ::protobuf::RepeatedField::new()) + } + + // repeated .google.bigtable.v1.RowRange row_ranges = 2; + + + pub fn get_row_ranges(&self) -> &[RowRange] { + &self.row_ranges + } + pub fn clear_row_ranges(&mut self) { + self.row_ranges.clear(); + } + + // Param is passed by value, moved + pub fn set_row_ranges(&mut self, v: ::protobuf::RepeatedField) { + self.row_ranges = v; + } + + // Mutable pointer to the field. + pub fn mut_row_ranges(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.row_ranges + } + + // Take field + pub fn take_row_ranges(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.row_ranges, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowSet { + fn is_initialized(&self) -> bool { + for v in &self.row_ranges { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.row_keys)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.row_ranges)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.row_keys { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.row_ranges { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.row_keys { + os.write_bytes(1, &v)?; + }; + for v in &self.row_ranges { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowSet { + RowSet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_keys", + |m: &RowSet| { &m.row_keys }, + |m: &mut RowSet| { &mut m.row_keys }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "row_ranges", + |m: &RowSet| { &m.row_ranges }, + |m: &mut RowSet| { &mut m.row_ranges }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowSet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowSet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowSet, + }; + unsafe { + instance.get(RowSet::new) + } + } +} + +impl ::protobuf::Clear for RowSet { + fn clear(&mut self) { + self.row_keys.clear(); + self.row_ranges.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowSet { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ColumnRange { + // message fields + pub family_name: ::std::string::String, + // message oneof groups + pub start_qualifier: ::std::option::Option, + pub end_qualifier: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ColumnRange { + fn default() -> &'a ColumnRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ColumnRange_oneof_start_qualifier { + start_qualifier_inclusive(::std::vec::Vec), + start_qualifier_exclusive(::std::vec::Vec), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ColumnRange_oneof_end_qualifier { + end_qualifier_inclusive(::std::vec::Vec), + end_qualifier_exclusive(::std::vec::Vec), +} + +impl ColumnRange { + pub fn new() -> ColumnRange { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes start_qualifier_inclusive = 2; + + + pub fn get_start_qualifier_inclusive(&self) -> &[u8] { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_qualifier_inclusive(&mut self) { + self.start_qualifier = ::std::option::Option::None; + } + + pub fn has_start_qualifier_inclusive(&self) -> bool { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_qualifier_inclusive(&mut self, v: ::std::vec::Vec) { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_qualifier_inclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(_)) = self.start_qualifier { + } else { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(::std::vec::Vec::new())); + } + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_qualifier_inclusive(&mut self) -> ::std::vec::Vec { + if self.has_start_qualifier_inclusive() { + match self.start_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes start_qualifier_exclusive = 3; + + + pub fn get_start_qualifier_exclusive(&self) -> &[u8] { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_qualifier_exclusive(&mut self) { + self.start_qualifier = ::std::option::Option::None; + } + + pub fn has_start_qualifier_exclusive(&self) -> bool { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_qualifier_exclusive(&mut self, v: ::std::vec::Vec) { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_qualifier_exclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(_)) = self.start_qualifier { + } else { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(::std::vec::Vec::new())); + } + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_qualifier_exclusive(&mut self) -> ::std::vec::Vec { + if self.has_start_qualifier_exclusive() { + match self.start_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_qualifier_inclusive = 4; + + + pub fn get_end_qualifier_inclusive(&self) -> &[u8] { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_qualifier_inclusive(&mut self) { + self.end_qualifier = ::std::option::Option::None; + } + + pub fn has_end_qualifier_inclusive(&self) -> bool { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_qualifier_inclusive(&mut self, v: ::std::vec::Vec) { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_qualifier_inclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(_)) = self.end_qualifier { + } else { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(::std::vec::Vec::new())); + } + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_qualifier_inclusive(&mut self) -> ::std::vec::Vec { + if self.has_end_qualifier_inclusive() { + match self.end_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_qualifier_exclusive = 5; + + + pub fn get_end_qualifier_exclusive(&self) -> &[u8] { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_qualifier_exclusive(&mut self) { + self.end_qualifier = ::std::option::Option::None; + } + + pub fn has_end_qualifier_exclusive(&self) -> bool { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_qualifier_exclusive(&mut self, v: ::std::vec::Vec) { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_qualifier_exclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(_)) = self.end_qualifier { + } else { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(::std::vec::Vec::new())); + } + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_qualifier_exclusive(&mut self) -> ::std::vec::Vec { + if self.has_end_qualifier_exclusive() { + match self.end_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } +} + +impl ::protobuf::Message for ColumnRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(is.read_bytes()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(is.read_bytes()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if let ::std::option::Option::Some(ref v) = self.start_qualifier { + match v { + &ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_qualifier { + match v { + &ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + &ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(5, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if let ::std::option::Option::Some(ref v) = self.start_qualifier { + match v { + &ColumnRange_oneof_start_qualifier::start_qualifier_inclusive(ref v) => { + os.write_bytes(2, v)?; + }, + &ColumnRange_oneof_start_qualifier::start_qualifier_exclusive(ref v) => { + os.write_bytes(3, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_qualifier { + match v { + &ColumnRange_oneof_end_qualifier::end_qualifier_inclusive(ref v) => { + os.write_bytes(4, v)?; + }, + &ColumnRange_oneof_end_qualifier::end_qualifier_exclusive(ref v) => { + os.write_bytes(5, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ColumnRange { + ColumnRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &ColumnRange| { &m.family_name }, + |m: &mut ColumnRange| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_qualifier_inclusive", + ColumnRange::has_start_qualifier_inclusive, + ColumnRange::get_start_qualifier_inclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_qualifier_exclusive", + ColumnRange::has_start_qualifier_exclusive, + ColumnRange::get_start_qualifier_exclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_qualifier_inclusive", + ColumnRange::has_end_qualifier_inclusive, + ColumnRange::get_end_qualifier_inclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_qualifier_exclusive", + ColumnRange::has_end_qualifier_exclusive, + ColumnRange::get_end_qualifier_exclusive, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ColumnRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ColumnRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ColumnRange, + }; + unsafe { + instance.get(ColumnRange::new) + } + } +} + +impl ::protobuf::Clear for ColumnRange { + fn clear(&mut self) { + self.family_name.clear(); + self.start_qualifier = ::std::option::Option::None; + self.start_qualifier = ::std::option::Option::None; + self.end_qualifier = ::std::option::Option::None; + self.end_qualifier = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ColumnRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ColumnRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TimestampRange { + // message fields + pub start_timestamp_micros: i64, + pub end_timestamp_micros: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TimestampRange { + fn default() -> &'a TimestampRange { + ::default_instance() + } +} + +impl TimestampRange { + pub fn new() -> TimestampRange { + ::std::default::Default::default() + } + + // int64 start_timestamp_micros = 1; + + + pub fn get_start_timestamp_micros(&self) -> i64 { + self.start_timestamp_micros + } + pub fn clear_start_timestamp_micros(&mut self) { + self.start_timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_start_timestamp_micros(&mut self, v: i64) { + self.start_timestamp_micros = v; + } + + // int64 end_timestamp_micros = 2; + + + pub fn get_end_timestamp_micros(&self) -> i64 { + self.end_timestamp_micros + } + pub fn clear_end_timestamp_micros(&mut self) { + self.end_timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_end_timestamp_micros(&mut self, v: i64) { + self.end_timestamp_micros = v; + } +} + +impl ::protobuf::Message for TimestampRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.start_timestamp_micros = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.end_timestamp_micros = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.start_timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(1, self.start_timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if self.end_timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(2, self.end_timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.start_timestamp_micros != 0 { + os.write_int64(1, self.start_timestamp_micros)?; + } + if self.end_timestamp_micros != 0 { + os.write_int64(2, self.end_timestamp_micros)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TimestampRange { + TimestampRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "start_timestamp_micros", + |m: &TimestampRange| { &m.start_timestamp_micros }, + |m: &mut TimestampRange| { &mut m.start_timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "end_timestamp_micros", + |m: &TimestampRange| { &m.end_timestamp_micros }, + |m: &mut TimestampRange| { &mut m.end_timestamp_micros }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TimestampRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TimestampRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TimestampRange, + }; + unsafe { + instance.get(TimestampRange::new) + } + } +} + +impl ::protobuf::Clear for TimestampRange { + fn clear(&mut self) { + self.start_timestamp_micros = 0; + self.end_timestamp_micros = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TimestampRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TimestampRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ValueRange { + // message oneof groups + pub start_value: ::std::option::Option, + pub end_value: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ValueRange { + fn default() -> &'a ValueRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ValueRange_oneof_start_value { + start_value_inclusive(::std::vec::Vec), + start_value_exclusive(::std::vec::Vec), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ValueRange_oneof_end_value { + end_value_inclusive(::std::vec::Vec), + end_value_exclusive(::std::vec::Vec), +} + +impl ValueRange { + pub fn new() -> ValueRange { + ::std::default::Default::default() + } + + // bytes start_value_inclusive = 1; + + + pub fn get_start_value_inclusive(&self) -> &[u8] { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_value_inclusive(&mut self) { + self.start_value = ::std::option::Option::None; + } + + pub fn has_start_value_inclusive(&self) -> bool { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_value_inclusive(&mut self, v: ::std::vec::Vec) { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_value_inclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(_)) = self.start_value { + } else { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(::std::vec::Vec::new())); + } + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_value_inclusive(&mut self) -> ::std::vec::Vec { + if self.has_start_value_inclusive() { + match self.start_value.take() { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes start_value_exclusive = 2; + + + pub fn get_start_value_exclusive(&self) -> &[u8] { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_value_exclusive(&mut self) { + self.start_value = ::std::option::Option::None; + } + + pub fn has_start_value_exclusive(&self) -> bool { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_value_exclusive(&mut self, v: ::std::vec::Vec) { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_value_exclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(_)) = self.start_value { + } else { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(::std::vec::Vec::new())); + } + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_value_exclusive(&mut self) -> ::std::vec::Vec { + if self.has_start_value_exclusive() { + match self.start_value.take() { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_value_inclusive = 3; + + + pub fn get_end_value_inclusive(&self) -> &[u8] { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_value_inclusive(&mut self) { + self.end_value = ::std::option::Option::None; + } + + pub fn has_end_value_inclusive(&self) -> bool { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_value_inclusive(&mut self, v: ::std::vec::Vec) { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_value_inclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(_)) = self.end_value { + } else { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(::std::vec::Vec::new())); + } + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_value_inclusive(&mut self) -> ::std::vec::Vec { + if self.has_end_value_inclusive() { + match self.end_value.take() { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_value_exclusive = 4; + + + pub fn get_end_value_exclusive(&self) -> &[u8] { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_value_exclusive(&mut self) { + self.end_value = ::std::option::Option::None; + } + + pub fn has_end_value_exclusive(&self) -> bool { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_value_exclusive(&mut self, v: ::std::vec::Vec) { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_value_exclusive(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(_)) = self.end_value { + } else { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(::std::vec::Vec::new())); + } + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_value_exclusive(&mut self) -> ::std::vec::Vec { + if self.has_end_value_exclusive() { + match self.end_value.take() { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } +} + +impl ::protobuf::Message for ValueRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_inclusive(is.read_bytes()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_exclusive(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_inclusive(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_exclusive(is.read_bytes()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.start_value { + match v { + &ValueRange_oneof_start_value::start_value_inclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(1, &v); + }, + &ValueRange_oneof_start_value::start_value_exclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_value { + match v { + &ValueRange_oneof_end_value::end_value_inclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + &ValueRange_oneof_end_value::end_value_exclusive(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.start_value { + match v { + &ValueRange_oneof_start_value::start_value_inclusive(ref v) => { + os.write_bytes(1, v)?; + }, + &ValueRange_oneof_start_value::start_value_exclusive(ref v) => { + os.write_bytes(2, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_value { + match v { + &ValueRange_oneof_end_value::end_value_inclusive(ref v) => { + os.write_bytes(3, v)?; + }, + &ValueRange_oneof_end_value::end_value_exclusive(ref v) => { + os.write_bytes(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ValueRange { + ValueRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_value_inclusive", + ValueRange::has_start_value_inclusive, + ValueRange::get_start_value_inclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_value_exclusive", + ValueRange::has_start_value_exclusive, + ValueRange::get_start_value_exclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_value_inclusive", + ValueRange::has_end_value_inclusive, + ValueRange::get_end_value_inclusive, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_value_exclusive", + ValueRange::has_end_value_exclusive, + ValueRange::get_end_value_exclusive, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ValueRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ValueRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ValueRange, + }; + unsafe { + instance.get(ValueRange::new) + } + } +} + +impl ::protobuf::Clear for ValueRange { + fn clear(&mut self) { + self.start_value = ::std::option::Option::None; + self.start_value = ::std::option::Option::None; + self.end_value = ::std::option::Option::None; + self.end_value = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ValueRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ValueRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter { + // message oneof groups + pub filter: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter { + fn default() -> &'a RowFilter { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum RowFilter_oneof_filter { + chain(RowFilter_Chain), + interleave(RowFilter_Interleave), + condition(RowFilter_Condition), + sink(bool), + pass_all_filter(bool), + block_all_filter(bool), + row_key_regex_filter(::std::vec::Vec), + row_sample_filter(f64), + family_name_regex_filter(::std::string::String), + column_qualifier_regex_filter(::std::vec::Vec), + column_range_filter(ColumnRange), + timestamp_range_filter(TimestampRange), + value_regex_filter(::std::vec::Vec), + value_range_filter(ValueRange), + cells_per_row_offset_filter(i32), + cells_per_row_limit_filter(i32), + cells_per_column_limit_filter(i32), + strip_value_transformer(bool), + apply_label_transformer(::std::string::String), +} + +impl RowFilter { + pub fn new() -> RowFilter { + ::std::default::Default::default() + } + + // .google.bigtable.v1.RowFilter.Chain chain = 1; + + + pub fn get_chain(&self) -> &RowFilter_Chain { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(ref v)) => v, + _ => RowFilter_Chain::default_instance(), + } + } + pub fn clear_chain(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_chain(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_chain(&mut self, v: RowFilter_Chain) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(v)) + } + + // Mutable pointer to the field. + pub fn mut_chain(&mut self) -> &mut RowFilter_Chain { + if let ::std::option::Option::Some(RowFilter_oneof_filter::chain(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(RowFilter_Chain::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_chain(&mut self) -> RowFilter_Chain { + if self.has_chain() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Chain::new() + } + } + + // .google.bigtable.v1.RowFilter.Interleave interleave = 2; + + + pub fn get_interleave(&self) -> &RowFilter_Interleave { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(ref v)) => v, + _ => RowFilter_Interleave::default_instance(), + } + } + pub fn clear_interleave(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_interleave(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_interleave(&mut self, v: RowFilter_Interleave) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(v)) + } + + // Mutable pointer to the field. + pub fn mut_interleave(&mut self) -> &mut RowFilter_Interleave { + if let ::std::option::Option::Some(RowFilter_oneof_filter::interleave(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(RowFilter_Interleave::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_interleave(&mut self) -> RowFilter_Interleave { + if self.has_interleave() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Interleave::new() + } + } + + // .google.bigtable.v1.RowFilter.Condition condition = 3; + + + pub fn get_condition(&self) -> &RowFilter_Condition { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(ref v)) => v, + _ => RowFilter_Condition::default_instance(), + } + } + pub fn clear_condition(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_condition(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_condition(&mut self, v: RowFilter_Condition) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(v)) + } + + // Mutable pointer to the field. + pub fn mut_condition(&mut self) -> &mut RowFilter_Condition { + if let ::std::option::Option::Some(RowFilter_oneof_filter::condition(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(RowFilter_Condition::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_condition(&mut self) -> RowFilter_Condition { + if self.has_condition() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Condition::new() + } + } + + // bool sink = 16; + + + pub fn get_sink(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::sink(v)) => v, + _ => false, + } + } + pub fn clear_sink(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_sink(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::sink(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_sink(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::sink(v)) + } + + // bool pass_all_filter = 17; + + + pub fn get_pass_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(v)) => v, + _ => false, + } + } + pub fn clear_pass_all_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_pass_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_pass_all_filter(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(v)) + } + + // bool block_all_filter = 18; + + + pub fn get_block_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(v)) => v, + _ => false, + } + } + pub fn clear_block_all_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_block_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_block_all_filter(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(v)) + } + + // bytes row_key_regex_filter = 4; + + + pub fn get_row_key_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_row_key_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_row_key_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_key_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_key_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_key_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_row_key_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // double row_sample_filter = 14; + + + pub fn get_row_sample_filter(&self) -> f64 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(v)) => v, + _ => 0., + } + } + pub fn clear_row_sample_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_row_sample_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_sample_filter(&mut self, v: f64) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(v)) + } + + // string family_name_regex_filter = 5; + + + pub fn get_family_name_regex_filter(&self) -> &str { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(ref v)) => v, + _ => "", + } + } + pub fn clear_family_name_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_family_name_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_family_name_regex_filter(&mut self, v: ::std::string::String) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_family_name_regex_filter(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(::std::string::String::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_family_name_regex_filter(&mut self) -> ::std::string::String { + if self.has_family_name_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } + + // bytes column_qualifier_regex_filter = 6; + + + pub fn get_column_qualifier_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_column_qualifier_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_column_qualifier_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_column_qualifier_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_column_qualifier_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_column_qualifier_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_column_qualifier_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.bigtable.v1.ColumnRange column_range_filter = 7; + + + pub fn get_column_range_filter(&self) -> &ColumnRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ref v)) => v, + _ => ColumnRange::default_instance(), + } + } + pub fn clear_column_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_column_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_column_range_filter(&mut self, v: ColumnRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_column_range_filter(&mut self) -> &mut ColumnRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ColumnRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_column_range_filter(&mut self) -> ColumnRange { + if self.has_column_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(v)) => v, + _ => panic!(), + } + } else { + ColumnRange::new() + } + } + + // .google.bigtable.v1.TimestampRange timestamp_range_filter = 8; + + + pub fn get_timestamp_range_filter(&self) -> &TimestampRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(ref v)) => v, + _ => TimestampRange::default_instance(), + } + } + pub fn clear_timestamp_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_timestamp_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_timestamp_range_filter(&mut self, v: TimestampRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_timestamp_range_filter(&mut self) -> &mut TimestampRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(TimestampRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_timestamp_range_filter(&mut self) -> TimestampRange { + if self.has_timestamp_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(v)) => v, + _ => panic!(), + } + } else { + TimestampRange::new() + } + } + + // bytes value_regex_filter = 9; + + + pub fn get_value_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_value_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_value_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_value_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_value_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_value_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_value_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.bigtable.v1.ValueRange value_range_filter = 15; + + + pub fn get_value_range_filter(&self) -> &ValueRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ref v)) => v, + _ => ValueRange::default_instance(), + } + } + pub fn clear_value_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_value_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_value_range_filter(&mut self, v: ValueRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_value_range_filter(&mut self) -> &mut ValueRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ValueRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_value_range_filter(&mut self) -> ValueRange { + if self.has_value_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(v)) => v, + _ => panic!(), + } + } else { + ValueRange::new() + } + } + + // int32 cells_per_row_offset_filter = 10; + + + pub fn get_cells_per_row_offset_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_row_offset_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_row_offset_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_row_offset_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(v)) + } + + // int32 cells_per_row_limit_filter = 11; + + + pub fn get_cells_per_row_limit_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_row_limit_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_row_limit_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_row_limit_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(v)) + } + + // int32 cells_per_column_limit_filter = 12; + + + pub fn get_cells_per_column_limit_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_column_limit_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_column_limit_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_column_limit_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(v)) + } + + // bool strip_value_transformer = 13; + + + pub fn get_strip_value_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(v)) => v, + _ => false, + } + } + pub fn clear_strip_value_transformer(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_strip_value_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_strip_value_transformer(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(v)) + } + + // string apply_label_transformer = 19; + + + pub fn get_apply_label_transformer(&self) -> &str { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(ref v)) => v, + _ => "", + } + } + pub fn clear_apply_label_transformer(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_apply_label_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_apply_label_transformer(&mut self, v: ::std::string::String) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(v)) + } + + // Mutable pointer to the field. + pub fn mut_apply_label_transformer(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(::std::string::String::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_apply_label_transformer(&mut self) -> ::std::string::String { + if self.has_apply_label_transformer() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } +} + +impl ::protobuf::Message for RowFilter { + fn is_initialized(&self) -> bool { + if let Some(RowFilter_oneof_filter::chain(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::interleave(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::condition(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::column_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::timestamp_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::value_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(is.read_message()?)); + }, + 16 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::sink(is.read_bool()?)); + }, + 17 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(is.read_bool()?)); + }, + 18 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(is.read_bool()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(is.read_bytes()?)); + }, + 14 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(is.read_double()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(is.read_string()?)); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(is.read_bytes()?)); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(is.read_message()?)); + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(is.read_message()?)); + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(is.read_bytes()?)); + }, + 15 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(is.read_message()?)); + }, + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(is.read_int32()?)); + }, + 11 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(is.read_int32()?)); + }, + 12 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(is.read_int32()?)); + }, + 13 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(is.read_bool()?)); + }, + 19 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(is.read_string()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.filter { + match v { + &RowFilter_oneof_filter::chain(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::interleave(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::condition(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::sink(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::pass_all_filter(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::block_all_filter(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::row_key_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + &RowFilter_oneof_filter::row_sample_filter(v) => { + my_size += 9; + }, + &RowFilter_oneof_filter::family_name_regex_filter(ref v) => { + my_size += ::protobuf::rt::string_size(5, &v); + }, + &RowFilter_oneof_filter::column_qualifier_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(6, &v); + }, + &RowFilter_oneof_filter::column_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::timestamp_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::value_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(9, &v); + }, + &RowFilter_oneof_filter::value_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::cells_per_row_offset_filter(v) => { + my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::cells_per_row_limit_filter(v) => { + my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::cells_per_column_limit_filter(v) => { + my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::strip_value_transformer(v) => { + my_size += 2; + }, + &RowFilter_oneof_filter::apply_label_transformer(ref v) => { + my_size += ::protobuf::rt::string_size(19, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.filter { + match v { + &RowFilter_oneof_filter::chain(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::interleave(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::condition(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::sink(v) => { + os.write_bool(16, v)?; + }, + &RowFilter_oneof_filter::pass_all_filter(v) => { + os.write_bool(17, v)?; + }, + &RowFilter_oneof_filter::block_all_filter(v) => { + os.write_bool(18, v)?; + }, + &RowFilter_oneof_filter::row_key_regex_filter(ref v) => { + os.write_bytes(4, v)?; + }, + &RowFilter_oneof_filter::row_sample_filter(v) => { + os.write_double(14, v)?; + }, + &RowFilter_oneof_filter::family_name_regex_filter(ref v) => { + os.write_string(5, v)?; + }, + &RowFilter_oneof_filter::column_qualifier_regex_filter(ref v) => { + os.write_bytes(6, v)?; + }, + &RowFilter_oneof_filter::column_range_filter(ref v) => { + os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::timestamp_range_filter(ref v) => { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::value_regex_filter(ref v) => { + os.write_bytes(9, v)?; + }, + &RowFilter_oneof_filter::value_range_filter(ref v) => { + os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::cells_per_row_offset_filter(v) => { + os.write_int32(10, v)?; + }, + &RowFilter_oneof_filter::cells_per_row_limit_filter(v) => { + os.write_int32(11, v)?; + }, + &RowFilter_oneof_filter::cells_per_column_limit_filter(v) => { + os.write_int32(12, v)?; + }, + &RowFilter_oneof_filter::strip_value_transformer(v) => { + os.write_bool(13, v)?; + }, + &RowFilter_oneof_filter::apply_label_transformer(ref v) => { + os.write_string(19, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter { + RowFilter::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Chain>( + "chain", + RowFilter::has_chain, + RowFilter::get_chain, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Interleave>( + "interleave", + RowFilter::has_interleave, + RowFilter::get_interleave, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Condition>( + "condition", + RowFilter::has_condition, + RowFilter::get_condition, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "sink", + RowFilter::has_sink, + RowFilter::get_sink, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "pass_all_filter", + RowFilter::has_pass_all_filter, + RowFilter::get_pass_all_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "block_all_filter", + RowFilter::has_block_all_filter, + RowFilter::get_block_all_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "row_key_regex_filter", + RowFilter::has_row_key_regex_filter, + RowFilter::get_row_key_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>( + "row_sample_filter", + RowFilter::has_row_sample_filter, + RowFilter::get_row_sample_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "family_name_regex_filter", + RowFilter::has_family_name_regex_filter, + RowFilter::get_family_name_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "column_qualifier_regex_filter", + RowFilter::has_column_qualifier_regex_filter, + RowFilter::get_column_qualifier_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ColumnRange>( + "column_range_filter", + RowFilter::has_column_range_filter, + RowFilter::get_column_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TimestampRange>( + "timestamp_range_filter", + RowFilter::has_timestamp_range_filter, + RowFilter::get_timestamp_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "value_regex_filter", + RowFilter::has_value_regex_filter, + RowFilter::get_value_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ValueRange>( + "value_range_filter", + RowFilter::has_value_range_filter, + RowFilter::get_value_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_row_offset_filter", + RowFilter::has_cells_per_row_offset_filter, + RowFilter::get_cells_per_row_offset_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_row_limit_filter", + RowFilter::has_cells_per_row_limit_filter, + RowFilter::get_cells_per_row_limit_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_column_limit_filter", + RowFilter::has_cells_per_column_limit_filter, + RowFilter::get_cells_per_column_limit_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "strip_value_transformer", + RowFilter::has_strip_value_transformer, + RowFilter::get_strip_value_transformer, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "apply_label_transformer", + RowFilter::has_apply_label_transformer, + RowFilter::get_apply_label_transformer, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter, + }; + unsafe { + instance.get(RowFilter::new) + } + } +} + +impl ::protobuf::Clear for RowFilter { + fn clear(&mut self) { + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Chain { + // message fields + pub filters: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Chain { + fn default() -> &'a RowFilter_Chain { + ::default_instance() + } +} + +impl RowFilter_Chain { + pub fn new() -> RowFilter_Chain { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v1.RowFilter filters = 1; + + + pub fn get_filters(&self) -> &[RowFilter] { + &self.filters + } + pub fn clear_filters(&mut self) { + self.filters.clear(); + } + + // Param is passed by value, moved + pub fn set_filters(&mut self, v: ::protobuf::RepeatedField) { + self.filters = v; + } + + // Mutable pointer to the field. + pub fn mut_filters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.filters + } + + // Take field + pub fn take_filters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.filters, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowFilter_Chain { + fn is_initialized(&self) -> bool { + for v in &self.filters { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filters)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.filters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.filters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Chain { + RowFilter_Chain::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filters", + |m: &RowFilter_Chain| { &m.filters }, + |m: &mut RowFilter_Chain| { &mut m.filters }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Chain", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Chain { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Chain, + }; + unsafe { + instance.get(RowFilter_Chain::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Chain { + fn clear(&mut self) { + self.filters.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Chain { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Chain { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Interleave { + // message fields + pub filters: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Interleave { + fn default() -> &'a RowFilter_Interleave { + ::default_instance() + } +} + +impl RowFilter_Interleave { + pub fn new() -> RowFilter_Interleave { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v1.RowFilter filters = 1; + + + pub fn get_filters(&self) -> &[RowFilter] { + &self.filters + } + pub fn clear_filters(&mut self) { + self.filters.clear(); + } + + // Param is passed by value, moved + pub fn set_filters(&mut self, v: ::protobuf::RepeatedField) { + self.filters = v; + } + + // Mutable pointer to the field. + pub fn mut_filters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.filters + } + + // Take field + pub fn take_filters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.filters, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowFilter_Interleave { + fn is_initialized(&self) -> bool { + for v in &self.filters { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filters)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.filters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.filters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Interleave { + RowFilter_Interleave::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filters", + |m: &RowFilter_Interleave| { &m.filters }, + |m: &mut RowFilter_Interleave| { &mut m.filters }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Interleave", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Interleave { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Interleave, + }; + unsafe { + instance.get(RowFilter_Interleave::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Interleave { + fn clear(&mut self) { + self.filters.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Interleave { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Interleave { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Condition { + // message fields + pub predicate_filter: ::protobuf::SingularPtrField, + pub true_filter: ::protobuf::SingularPtrField, + pub false_filter: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Condition { + fn default() -> &'a RowFilter_Condition { + ::default_instance() + } +} + +impl RowFilter_Condition { + pub fn new() -> RowFilter_Condition { + ::std::default::Default::default() + } + + // .google.bigtable.v1.RowFilter predicate_filter = 1; + + + pub fn get_predicate_filter(&self) -> &RowFilter { + self.predicate_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_predicate_filter(&mut self) { + self.predicate_filter.clear(); + } + + pub fn has_predicate_filter(&self) -> bool { + self.predicate_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_predicate_filter(&mut self, v: RowFilter) { + self.predicate_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_predicate_filter(&mut self) -> &mut RowFilter { + if self.predicate_filter.is_none() { + self.predicate_filter.set_default(); + } + self.predicate_filter.as_mut().unwrap() + } + + // Take field + pub fn take_predicate_filter(&mut self) -> RowFilter { + self.predicate_filter.take().unwrap_or_else(|| RowFilter::new()) + } + + // .google.bigtable.v1.RowFilter true_filter = 2; + + + pub fn get_true_filter(&self) -> &RowFilter { + self.true_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_true_filter(&mut self) { + self.true_filter.clear(); + } + + pub fn has_true_filter(&self) -> bool { + self.true_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_true_filter(&mut self, v: RowFilter) { + self.true_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_true_filter(&mut self) -> &mut RowFilter { + if self.true_filter.is_none() { + self.true_filter.set_default(); + } + self.true_filter.as_mut().unwrap() + } + + // Take field + pub fn take_true_filter(&mut self) -> RowFilter { + self.true_filter.take().unwrap_or_else(|| RowFilter::new()) + } + + // .google.bigtable.v1.RowFilter false_filter = 3; + + + pub fn get_false_filter(&self) -> &RowFilter { + self.false_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_false_filter(&mut self) { + self.false_filter.clear(); + } + + pub fn has_false_filter(&self) -> bool { + self.false_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_false_filter(&mut self, v: RowFilter) { + self.false_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_false_filter(&mut self) -> &mut RowFilter { + if self.false_filter.is_none() { + self.false_filter.set_default(); + } + self.false_filter.as_mut().unwrap() + } + + // Take field + pub fn take_false_filter(&mut self) -> RowFilter { + self.false_filter.take().unwrap_or_else(|| RowFilter::new()) + } +} + +impl ::protobuf::Message for RowFilter_Condition { + fn is_initialized(&self) -> bool { + for v in &self.predicate_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.true_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.false_filter { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.predicate_filter)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.true_filter)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.false_filter)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.predicate_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.true_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.false_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.predicate_filter.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.true_filter.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.false_filter.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Condition { + RowFilter_Condition::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "predicate_filter", + |m: &RowFilter_Condition| { &m.predicate_filter }, + |m: &mut RowFilter_Condition| { &mut m.predicate_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "true_filter", + |m: &RowFilter_Condition| { &m.true_filter }, + |m: &mut RowFilter_Condition| { &mut m.true_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "false_filter", + |m: &RowFilter_Condition| { &m.false_filter }, + |m: &mut RowFilter_Condition| { &mut m.false_filter }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Condition", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Condition { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Condition, + }; + unsafe { + instance.get(RowFilter_Condition::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Condition { + fn clear(&mut self) { + self.predicate_filter.clear(); + self.true_filter.clear(); + self.false_filter.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Condition { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Condition { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation { + // message oneof groups + pub mutation: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation { + fn default() -> &'a Mutation { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum Mutation_oneof_mutation { + set_cell(Mutation_SetCell), + delete_from_column(Mutation_DeleteFromColumn), + delete_from_family(Mutation_DeleteFromFamily), + delete_from_row(Mutation_DeleteFromRow), +} + +impl Mutation { + pub fn new() -> Mutation { + ::std::default::Default::default() + } + + // .google.bigtable.v1.Mutation.SetCell set_cell = 1; + + + pub fn get_set_cell(&self) -> &Mutation_SetCell { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(ref v)) => v, + _ => Mutation_SetCell::default_instance(), + } + } + pub fn clear_set_cell(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_set_cell(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_set_cell(&mut self, v: Mutation_SetCell) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(v)) + } + + // Mutable pointer to the field. + pub fn mut_set_cell(&mut self) -> &mut Mutation_SetCell { + if let ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(Mutation_SetCell::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_set_cell(&mut self) -> Mutation_SetCell { + if self.has_set_cell() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(v)) => v, + _ => panic!(), + } + } else { + Mutation_SetCell::new() + } + } + + // .google.bigtable.v1.Mutation.DeleteFromColumn delete_from_column = 2; + + + pub fn get_delete_from_column(&self) -> &Mutation_DeleteFromColumn { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(ref v)) => v, + _ => Mutation_DeleteFromColumn::default_instance(), + } + } + pub fn clear_delete_from_column(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_column(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_column(&mut self, v: Mutation_DeleteFromColumn) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_column(&mut self) -> &mut Mutation_DeleteFromColumn { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(Mutation_DeleteFromColumn::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_column(&mut self) -> Mutation_DeleteFromColumn { + if self.has_delete_from_column() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromColumn::new() + } + } + + // .google.bigtable.v1.Mutation.DeleteFromFamily delete_from_family = 3; + + + pub fn get_delete_from_family(&self) -> &Mutation_DeleteFromFamily { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(ref v)) => v, + _ => Mutation_DeleteFromFamily::default_instance(), + } + } + pub fn clear_delete_from_family(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_family(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_family(&mut self, v: Mutation_DeleteFromFamily) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_family(&mut self) -> &mut Mutation_DeleteFromFamily { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(Mutation_DeleteFromFamily::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_family(&mut self) -> Mutation_DeleteFromFamily { + if self.has_delete_from_family() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromFamily::new() + } + } + + // .google.bigtable.v1.Mutation.DeleteFromRow delete_from_row = 4; + + + pub fn get_delete_from_row(&self) -> &Mutation_DeleteFromRow { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(ref v)) => v, + _ => Mutation_DeleteFromRow::default_instance(), + } + } + pub fn clear_delete_from_row(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_row(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_row(&mut self, v: Mutation_DeleteFromRow) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_row(&mut self) -> &mut Mutation_DeleteFromRow { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(Mutation_DeleteFromRow::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_row(&mut self) -> Mutation_DeleteFromRow { + if self.has_delete_from_row() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromRow::new() + } + } +} + +impl ::protobuf::Message for Mutation { + fn is_initialized(&self) -> bool { + if let Some(Mutation_oneof_mutation::set_cell(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_column(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_family(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_row(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.mutation { + match v { + &Mutation_oneof_mutation::set_cell(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_column(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_family(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_row(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.mutation { + match v { + &Mutation_oneof_mutation::set_cell(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_column(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_family(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_row(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation { + Mutation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_SetCell>( + "set_cell", + Mutation::has_set_cell, + Mutation::get_set_cell, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromColumn>( + "delete_from_column", + Mutation::has_delete_from_column, + Mutation::get_delete_from_column, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromFamily>( + "delete_from_family", + Mutation::has_delete_from_family, + Mutation::get_delete_from_family, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromRow>( + "delete_from_row", + Mutation::has_delete_from_row, + Mutation::get_delete_from_row, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation, + }; + unsafe { + instance.get(Mutation::new) + } + } +} + +impl ::protobuf::Clear for Mutation { + fn clear(&mut self) { + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_SetCell { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + pub timestamp_micros: i64, + pub value: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_SetCell { + fn default() -> &'a Mutation_SetCell { + ::default_instance() + } +} + +impl Mutation_SetCell { + pub fn new() -> Mutation_SetCell { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // int64 timestamp_micros = 3; + + + pub fn get_timestamp_micros(&self) -> i64 { + self.timestamp_micros + } + pub fn clear_timestamp_micros(&mut self) { + self.timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_timestamp_micros(&mut self, v: i64) { + self.timestamp_micros = v; + } + + // bytes value = 4; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for Mutation_SetCell { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.timestamp_micros = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if self.timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(3, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(4, &self.value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if self.timestamp_micros != 0 { + os.write_int64(3, self.timestamp_micros)?; + } + if !self.value.is_empty() { + os.write_bytes(4, &self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_SetCell { + Mutation_SetCell::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_SetCell| { &m.family_name }, + |m: &mut Mutation_SetCell| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &Mutation_SetCell| { &m.column_qualifier }, + |m: &mut Mutation_SetCell| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "timestamp_micros", + |m: &Mutation_SetCell| { &m.timestamp_micros }, + |m: &mut Mutation_SetCell| { &mut m.timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &Mutation_SetCell| { &m.value }, + |m: &mut Mutation_SetCell| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_SetCell", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_SetCell { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_SetCell, + }; + unsafe { + instance.get(Mutation_SetCell::new) + } + } +} + +impl ::protobuf::Clear for Mutation_SetCell { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.timestamp_micros = 0; + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_SetCell { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_SetCell { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromColumn { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + pub time_range: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromColumn { + fn default() -> &'a Mutation_DeleteFromColumn { + ::default_instance() + } +} + +impl Mutation_DeleteFromColumn { + pub fn new() -> Mutation_DeleteFromColumn { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // .google.bigtable.v1.TimestampRange time_range = 3; + + + pub fn get_time_range(&self) -> &TimestampRange { + self.time_range.as_ref().unwrap_or_else(|| TimestampRange::default_instance()) + } + pub fn clear_time_range(&mut self) { + self.time_range.clear(); + } + + pub fn has_time_range(&self) -> bool { + self.time_range.is_some() + } + + // Param is passed by value, moved + pub fn set_time_range(&mut self, v: TimestampRange) { + self.time_range = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_time_range(&mut self) -> &mut TimestampRange { + if self.time_range.is_none() { + self.time_range.set_default(); + } + self.time_range.as_mut().unwrap() + } + + // Take field + pub fn take_time_range(&mut self) -> TimestampRange { + self.time_range.take().unwrap_or_else(|| TimestampRange::new()) + } +} + +impl ::protobuf::Message for Mutation_DeleteFromColumn { + fn is_initialized(&self) -> bool { + for v in &self.time_range { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.time_range)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if let Some(ref v) = self.time_range.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if let Some(ref v) = self.time_range.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromColumn { + Mutation_DeleteFromColumn::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_DeleteFromColumn| { &m.family_name }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &Mutation_DeleteFromColumn| { &m.column_qualifier }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "time_range", + |m: &Mutation_DeleteFromColumn| { &m.time_range }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.time_range }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromColumn", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromColumn { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromColumn, + }; + unsafe { + instance.get(Mutation_DeleteFromColumn::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromColumn { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.time_range.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromColumn { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromColumn { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromFamily { + // message fields + pub family_name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromFamily { + fn default() -> &'a Mutation_DeleteFromFamily { + ::default_instance() + } +} + +impl Mutation_DeleteFromFamily { + pub fn new() -> Mutation_DeleteFromFamily { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Mutation_DeleteFromFamily { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromFamily { + Mutation_DeleteFromFamily::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_DeleteFromFamily| { &m.family_name }, + |m: &mut Mutation_DeleteFromFamily| { &mut m.family_name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromFamily", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromFamily { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromFamily, + }; + unsafe { + instance.get(Mutation_DeleteFromFamily::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromFamily { + fn clear(&mut self) { + self.family_name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromFamily { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromFamily { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromRow { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromRow { + fn default() -> &'a Mutation_DeleteFromRow { + ::default_instance() + } +} + +impl Mutation_DeleteFromRow { + pub fn new() -> Mutation_DeleteFromRow { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for Mutation_DeleteFromRow { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromRow { + Mutation_DeleteFromRow::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromRow", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromRow { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromRow, + }; + unsafe { + instance.get(Mutation_DeleteFromRow::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromRow { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromRow { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromRow { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadModifyWriteRule { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + // message oneof groups + pub rule: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadModifyWriteRule { + fn default() -> &'a ReadModifyWriteRule { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ReadModifyWriteRule_oneof_rule { + append_value(::std::vec::Vec), + increment_amount(i64), +} + +impl ReadModifyWriteRule { + pub fn new() -> ReadModifyWriteRule { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // bytes append_value = 3; + + + pub fn get_append_value(&self) -> &[u8] { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(ref v)) => v, + _ => &[], + } + } + pub fn clear_append_value(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_append_value(&self) -> bool { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_append_value(&mut self, v: ::std::vec::Vec) { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_append_value(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(::std::vec::Vec::new())); + } + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_append_value(&mut self) -> ::std::vec::Vec { + if self.has_append_value() { + match self.rule.take() { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // int64 increment_amount = 4; + + + pub fn get_increment_amount(&self) -> i64 { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(v)) => v, + _ => 0, + } + } + pub fn clear_increment_amount(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_increment_amount(&self) -> bool { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_increment_amount(&mut self, v: i64) { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(v)) + } +} + +impl ::protobuf::Message for ReadModifyWriteRule { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(is.read_int64()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &ReadModifyWriteRule_oneof_rule::append_value(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + &ReadModifyWriteRule_oneof_rule::increment_amount(v) => { + my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &ReadModifyWriteRule_oneof_rule::append_value(ref v) => { + os.write_bytes(3, v)?; + }, + &ReadModifyWriteRule_oneof_rule::increment_amount(v) => { + os.write_int64(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadModifyWriteRule { + ReadModifyWriteRule::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &ReadModifyWriteRule| { &m.family_name }, + |m: &mut ReadModifyWriteRule| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &ReadModifyWriteRule| { &m.column_qualifier }, + |m: &mut ReadModifyWriteRule| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "append_value", + ReadModifyWriteRule::has_append_value, + ReadModifyWriteRule::get_append_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>( + "increment_amount", + ReadModifyWriteRule::has_increment_amount, + ReadModifyWriteRule::get_increment_amount, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadModifyWriteRule", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadModifyWriteRule { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadModifyWriteRule, + }; + unsafe { + instance.get(ReadModifyWriteRule::new) + } + } +} + +impl ::protobuf::Clear for ReadModifyWriteRule { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadModifyWriteRule { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRule { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n&google/bigtable/v1/bigtable_data.proto\x12\x12google.bigtable.v1\"O\n\ + \x03Row\x12\x10\n\x03key\x18\x01\x20\x01(\x0cR\x03key\x126\n\x08families\ + \x18\x02\x20\x03(\x0b2\x1a.google.bigtable.v1.FamilyR\x08families\"R\n\ + \x06Family\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x124\n\x07colum\ + ns\x18\x02\x20\x03(\x0b2\x1a.google.bigtable.v1.ColumnR\x07columns\"V\n\ + \x06Column\x12\x1c\n\tqualifier\x18\x01\x20\x01(\x0cR\tqualifier\x12.\n\ + \x05cells\x18\x02\x20\x03(\x0b2\x18.google.bigtable.v1.CellR\x05cells\"_\ + \n\x04Cell\x12)\n\x10timestamp_micros\x18\x01\x20\x01(\x03R\x0ftimestamp\ + Micros\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05value\x12\x16\n\x06la\ + bels\x18\x03\x20\x03(\tR\x06labels\"@\n\x08RowRange\x12\x1b\n\tstart_key\ + \x18\x02\x20\x01(\x0cR\x08startKey\x12\x17\n\x07end_key\x18\x03\x20\x01(\ + \x0cR\x06endKey\"`\n\x06RowSet\x12\x19\n\x08row_keys\x18\x01\x20\x03(\ + \x0cR\x07rowKeys\x12;\n\nrow_ranges\x18\x02\x20\x03(\x0b2\x1c.google.big\ + table.v1.RowRangeR\trowRanges\"\xc2\x02\n\x0bColumnRange\x12\x1f\n\x0bfa\ + mily_name\x18\x01\x20\x01(\tR\nfamilyName\x12<\n\x19start_qualifier_incl\ + usive\x18\x02\x20\x01(\x0cH\0R\x17startQualifierInclusive\x12<\n\x19star\ + t_qualifier_exclusive\x18\x03\x20\x01(\x0cH\0R\x17startQualifierExclusiv\ + e\x128\n\x17end_qualifier_inclusive\x18\x04\x20\x01(\x0cH\x01R\x15endQua\ + lifierInclusive\x128\n\x17end_qualifier_exclusive\x18\x05\x20\x01(\x0cH\ + \x01R\x15endQualifierExclusiveB\x11\n\x0fstart_qualifierB\x0f\n\rend_qua\ + lifier\"x\n\x0eTimestampRange\x124\n\x16start_timestamp_micros\x18\x01\ + \x20\x01(\x03R\x14startTimestampMicros\x120\n\x14end_timestamp_micros\ + \x18\x02\x20\x01(\x03R\x12endTimestampMicros\"\xf8\x01\n\nValueRange\x12\ + 4\n\x15start_value_inclusive\x18\x01\x20\x01(\x0cH\0R\x13startValueInclu\ + sive\x124\n\x15start_value_exclusive\x18\x02\x20\x01(\x0cH\0R\x13startVa\ + lueExclusive\x120\n\x13end_value_inclusive\x18\x03\x20\x01(\x0cH\x01R\ + \x11endValueInclusive\x120\n\x13end_value_exclusive\x18\x04\x20\x01(\x0c\ + H\x01R\x11endValueExclusiveB\r\n\x0bstart_valueB\x0b\n\tend_value\"\xfc\ + \x0b\n\tRowFilter\x12;\n\x05chain\x18\x01\x20\x01(\x0b2#.google.bigtable\ + .v1.RowFilter.ChainH\0R\x05chain\x12J\n\ninterleave\x18\x02\x20\x01(\x0b\ + 2(.google.bigtable.v1.RowFilter.InterleaveH\0R\ninterleave\x12G\n\tcondi\ + tion\x18\x03\x20\x01(\x0b2'.google.bigtable.v1.RowFilter.ConditionH\0R\t\ + condition\x12\x14\n\x04sink\x18\x10\x20\x01(\x08H\0R\x04sink\x12(\n\x0fp\ + ass_all_filter\x18\x11\x20\x01(\x08H\0R\rpassAllFilter\x12*\n\x10block_a\ + ll_filter\x18\x12\x20\x01(\x08H\0R\x0eblockAllFilter\x121\n\x14row_key_r\ + egex_filter\x18\x04\x20\x01(\x0cH\0R\x11rowKeyRegexFilter\x12,\n\x11row_\ + sample_filter\x18\x0e\x20\x01(\x01H\0R\x0frowSampleFilter\x129\n\x18fami\ + ly_name_regex_filter\x18\x05\x20\x01(\tH\0R\x15familyNameRegexFilter\x12\ + C\n\x1dcolumn_qualifier_regex_filter\x18\x06\x20\x01(\x0cH\0R\x1acolumnQ\ + ualifierRegexFilter\x12Q\n\x13column_range_filter\x18\x07\x20\x01(\x0b2\ + \x1f.google.bigtable.v1.ColumnRangeH\0R\x11columnRangeFilter\x12Z\n\x16t\ + imestamp_range_filter\x18\x08\x20\x01(\x0b2\".google.bigtable.v1.Timesta\ + mpRangeH\0R\x14timestampRangeFilter\x12.\n\x12value_regex_filter\x18\t\ + \x20\x01(\x0cH\0R\x10valueRegexFilter\x12N\n\x12value_range_filter\x18\ + \x0f\x20\x01(\x0b2\x1e.google.bigtable.v1.ValueRangeH\0R\x10valueRangeFi\ + lter\x12>\n\x1bcells_per_row_offset_filter\x18\n\x20\x01(\x05H\0R\x17cel\ + lsPerRowOffsetFilter\x12<\n\x1acells_per_row_limit_filter\x18\x0b\x20\ + \x01(\x05H\0R\x16cellsPerRowLimitFilter\x12B\n\x1dcells_per_column_limit\ + _filter\x18\x0c\x20\x01(\x05H\0R\x19cellsPerColumnLimitFilter\x128\n\x17\ + strip_value_transformer\x18\r\x20\x01(\x08H\0R\x15stripValueTransformer\ + \x128\n\x17apply_label_transformer\x18\x13\x20\x01(\tH\0R\x15applyLabelT\ + ransformer\x1a@\n\x05Chain\x127\n\x07filters\x18\x01\x20\x03(\x0b2\x1d.g\ + oogle.bigtable.v1.RowFilterR\x07filters\x1aE\n\nInterleave\x127\n\x07fil\ + ters\x18\x01\x20\x03(\x0b2\x1d.google.bigtable.v1.RowFilterR\x07filters\ + \x1a\xd7\x01\n\tCondition\x12H\n\x10predicate_filter\x18\x01\x20\x01(\ + \x0b2\x1d.google.bigtable.v1.RowFilterR\x0fpredicateFilter\x12>\n\x0btru\ + e_filter\x18\x02\x20\x01(\x0b2\x1d.google.bigtable.v1.RowFilterR\ntrueFi\ + lter\x12@\n\x0cfalse_filter\x18\x03\x20\x01(\x0b2\x1d.google.bigtable.v1\ + .RowFilterR\x0bfalseFilterB\x08\n\x06filter\"\xf0\x05\n\x08Mutation\x12A\ + \n\x08set_cell\x18\x01\x20\x01(\x0b2$.google.bigtable.v1.Mutation.SetCel\ + lH\0R\x07setCell\x12]\n\x12delete_from_column\x18\x02\x20\x01(\x0b2-.goo\ + gle.bigtable.v1.Mutation.DeleteFromColumnH\0R\x10deleteFromColumn\x12]\n\ + \x12delete_from_family\x18\x03\x20\x01(\x0b2-.google.bigtable.v1.Mutatio\ + n.DeleteFromFamilyH\0R\x10deleteFromFamily\x12T\n\x0fdelete_from_row\x18\ + \x04\x20\x01(\x0b2*.google.bigtable.v1.Mutation.DeleteFromRowH\0R\rdelet\ + eFromRow\x1a\x96\x01\n\x07SetCell\x12\x1f\n\x0bfamily_name\x18\x01\x20\ + \x01(\tR\nfamilyName\x12)\n\x10column_qualifier\x18\x02\x20\x01(\x0cR\ + \x0fcolumnQualifier\x12)\n\x10timestamp_micros\x18\x03\x20\x01(\x03R\x0f\ + timestampMicros\x12\x14\n\x05value\x18\x04\x20\x01(\x0cR\x05value\x1a\ + \xa1\x01\n\x10DeleteFromColumn\x12\x1f\n\x0bfamily_name\x18\x01\x20\x01(\ + \tR\nfamilyName\x12)\n\x10column_qualifier\x18\x02\x20\x01(\x0cR\x0fcolu\ + mnQualifier\x12A\n\ntime_range\x18\x03\x20\x01(\x0b2\".google.bigtable.v\ + 1.TimestampRangeR\ttimeRange\x1a3\n\x10DeleteFromFamily\x12\x1f\n\x0bfam\ + ily_name\x18\x01\x20\x01(\tR\nfamilyName\x1a\x0f\n\rDeleteFromRowB\n\n\ + \x08mutation\"\xbb\x01\n\x13ReadModifyWriteRule\x12\x1f\n\x0bfamily_name\ + \x18\x01\x20\x01(\tR\nfamilyName\x12)\n\x10column_qualifier\x18\x02\x20\ + \x01(\x0cR\x0fcolumnQualifier\x12#\n\x0cappend_value\x18\x03\x20\x01(\ + \x0cH\0R\x0bappendValue\x12+\n\x10increment_amount\x18\x04\x20\x01(\x03H\ + \0R\x0fincrementAmountB\x06\n\x04ruleBi\n\x16com.google.bigtable.v1B\x11\ + BigtableDataProtoP\x01Z:google.golang.org/genproto/googleapis/bigtable/v\ + 1;bigtableJ\xf7\xb2\x01\n\x07\x12\x05\x0e\0\x83\x04\x01\n\xbd\x04\n\x01\ + \x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\ + \n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\ + \x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\ + \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\ + y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\ + \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\ + ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\ + \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\ + buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\ + \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\ + \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\ + guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\ + e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1b\n\x08\n\x01\x08\x12\ + \x03\x12\0Q\n\t\n\x02\x08\x0b\x12\x03\x12\0Q\n\x08\n\x01\x08\x12\x03\x13\ + \0\"\n\t\n\x02\x08\n\x12\x03\x13\0\"\n\x08\n\x01\x08\x12\x03\x14\02\n\t\ + \n\x02\x08\x08\x12\x03\x14\02\n\x08\n\x01\x08\x12\x03\x15\0/\n\t\n\x02\ + \x08\x01\x12\x03\x15\0/\n\x90\x01\n\x02\x04\0\x12\x04\x1a\0#\x01\x1a\x83\ + \x01\x20Specifies\x20the\x20complete\x20(requested)\x20contents\x20of\ + \x20a\x20single\x20row\x20of\x20a\x20table.\n\x20Rows\x20which\x20exceed\ + \x20256MiB\x20in\x20size\x20cannot\x20be\x20read\x20in\x20full.\n\n\n\n\ + \x03\x04\0\x01\x12\x03\x1a\x08\x0b\n\xe2\x01\n\x04\x04\0\x02\0\x12\x03\ + \x1e\x02\x10\x1a\xd4\x01\x20The\x20unique\x20key\x20which\x20identifies\ + \x20this\x20row\x20within\x20its\x20table.\x20This\x20is\x20the\x20same\ + \n\x20key\x20that's\x20used\x20to\x20identify\x20the\x20row\x20in,\x20fo\ + r\x20example,\x20a\x20MutateRowRequest.\n\x20May\x20contain\x20any\x20no\ + n-empty\x20byte\x20string\x20up\x20to\x204KiB\x20in\x20length.\n\n\r\n\ + \x05\x04\0\x02\0\x04\x12\x04\x1e\x02\x1a\r\n\x0c\n\x05\x04\0\x02\0\x05\ + \x12\x03\x1e\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x1e\x08\x0b\n\ + \x0c\n\x05\x04\0\x02\0\x03\x12\x03\x1e\x0e\x0f\n{\n\x04\x04\0\x02\x01\ + \x12\x03\"\x02\x1f\x1an\x20May\x20be\x20empty,\x20but\x20only\x20if\x20t\ + he\x20entire\x20row\x20is\x20empty.\n\x20The\x20mutual\x20ordering\x20of\ + \x20column\x20families\x20is\x20not\x20specified.\n\n\x0c\n\x05\x04\0\ + \x02\x01\x04\x12\x03\"\x02\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03\"\x0b\ + \x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\"\x12\x1a\n\x0c\n\x05\x04\0\ + \x02\x01\x03\x12\x03\"\x1d\x1e\nX\n\x02\x04\x01\x12\x04&\01\x01\x1aL\x20\ + Specifies\x20(some\x20of)\x20the\x20contents\x20of\x20a\x20single\x20row\ + /column\x20family\x20of\x20a\x20table.\n\n\n\n\x03\x04\x01\x01\x12\x03&\ + \x08\x0e\n\x83\x03\n\x04\x04\x01\x02\0\x12\x03-\x02\x12\x1a\xf5\x02\x20T\ + he\x20unique\x20key\x20which\x20identifies\x20this\x20family\x20within\ + \x20its\x20row.\x20This\x20is\x20the\n\x20same\x20key\x20that's\x20used\ + \x20to\x20identify\x20the\x20family\x20in,\x20for\x20example,\x20a\x20Ro\ + wFilter\n\x20which\x20sets\x20its\x20\"family_name_regex_filter\"\x20fie\ + ld.\n\x20Must\x20match\x20[-_.a-zA-Z0-9]+,\x20except\x20that\x20Aggregat\ + ingRowProcessors\x20may\n\x20produce\x20cells\x20in\x20a\x20sentinel\x20\ + family\x20with\x20an\x20empty\x20name.\n\x20Must\x20be\x20no\x20greater\ + \x20than\x2064\x20characters\x20in\x20length.\n\n\r\n\x05\x04\x01\x02\0\ + \x04\x12\x04-\x02&\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03-\x02\x08\n\ + \x0c\n\x05\x04\x01\x02\0\x01\x12\x03-\t\r\n\x0c\n\x05\x04\x01\x02\0\x03\ + \x12\x03-\x10\x11\nL\n\x04\x04\x01\x02\x01\x12\x030\x02\x1e\x1a?\x20Must\ + \x20not\x20be\x20empty.\x20Sorted\x20in\x20order\x20of\x20increasing\x20\ + \"qualifier\".\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x030\x02\n\n\x0c\n\ + \x05\x04\x01\x02\x01\x06\x12\x030\x0b\x11\n\x0c\n\x05\x04\x01\x02\x01\ + \x01\x12\x030\x12\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x030\x1c\x1d\n\ + Q\n\x02\x04\x02\x12\x044\0>\x01\x1aE\x20Specifies\x20(some\x20of)\x20the\ + \x20contents\x20of\x20a\x20single\x20row/column\x20of\x20a\x20table.\n\n\ + \n\n\x03\x04\x02\x01\x12\x034\x08\x0e\n\xad\x02\n\x04\x04\x02\x02\0\x12\ + \x03:\x02\x16\x1a\x9f\x02\x20The\x20unique\x20key\x20which\x20identifies\ + \x20this\x20column\x20within\x20its\x20family.\x20This\x20is\x20the\n\ + \x20same\x20key\x20that's\x20used\x20to\x20identify\x20the\x20column\x20\ + in,\x20for\x20example,\x20a\x20RowFilter\n\x20which\x20sets\x20its\x20\"\ + column_qualifier_regex_filter\"\x20field.\n\x20May\x20contain\x20any\x20\ + byte\x20string,\x20including\x20the\x20empty\x20string,\x20up\x20to\x201\ + 6kiB\x20in\n\x20length.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04:\x024\x10\ + \n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03:\x02\x07\n\x0c\n\x05\x04\x02\x02\ + \0\x01\x12\x03:\x08\x11\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03:\x14\x15\n\ + S\n\x04\x04\x02\x02\x01\x12\x03=\x02\x1a\x1aF\x20Must\x20not\x20be\x20em\ + pty.\x20Sorted\x20in\x20order\x20of\x20decreasing\x20\"timestamp_micros\ + \".\n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03=\x02\n\n\x0c\n\x05\x04\x02\ + \x02\x01\x06\x12\x03=\x0b\x0f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03=\ + \x10\x15\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03=\x18\x19\n[\n\x02\x04\ + \x03\x12\x04A\0Q\x01\x1aO\x20Specifies\x20(some\x20of)\x20the\x20content\ + s\x20of\x20a\x20single\x20row/column/timestamp\x20of\x20a\x20table.\n\n\ + \n\n\x03\x04\x03\x01\x12\x03A\x08\x0c\n\xf8\x02\n\x04\x04\x03\x02\0\x12\ + \x03H\x02\x1d\x1a\xea\x02\x20The\x20cell's\x20stored\x20timestamp,\x20wh\ + ich\x20also\x20uniquely\x20identifies\x20it\x20within\n\x20its\x20column\ + .\n\x20Values\x20are\x20always\x20expressed\x20in\x20microseconds,\x20bu\ + t\x20individual\x20tables\x20may\x20set\n\x20a\x20coarser\x20\"granulari\ + ty\"\x20to\x20further\x20restrict\x20the\x20allowed\x20values.\x20For\n\ + \x20example,\x20a\x20table\x20which\x20specifies\x20millisecond\x20granu\ + larity\x20will\x20only\x20allow\n\x20values\x20of\x20\"timestamp_micros\ + \"\x20which\x20are\x20multiples\x20of\x201000.\n\n\r\n\x05\x04\x03\x02\0\ + \x04\x12\x04H\x02A\x0e\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03H\x02\x07\n\ + \x0c\n\x05\x04\x03\x02\0\x01\x12\x03H\x08\x18\n\x0c\n\x05\x04\x03\x02\0\ + \x03\x12\x03H\x1b\x1c\n\x7f\n\x04\x04\x03\x02\x01\x12\x03M\x02\x12\x1ar\ + \x20The\x20value\x20stored\x20in\x20the\x20cell.\n\x20May\x20contain\x20\ + any\x20byte\x20string,\x20including\x20the\x20empty\x20string,\x20up\x20\ + to\x20100MiB\x20in\n\x20length.\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04M\ + \x02H\x1d\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03M\x02\x07\n\x0c\n\x05\ + \x04\x03\x02\x01\x01\x12\x03M\x08\r\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\ + \x03M\x10\x11\nY\n\x04\x04\x03\x02\x02\x12\x03P\x02\x1d\x1aL\x20Labels\ + \x20applied\x20to\x20the\x20cell\x20by\x20a\x20[RowFilter][google.bigtab\ + le.v1.RowFilter].\n\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03P\x02\n\n\x0c\ + \n\x05\x04\x03\x02\x02\x05\x12\x03P\x0b\x11\n\x0c\n\x05\x04\x03\x02\x02\ + \x01\x12\x03P\x12\x18\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03P\x1b\x1c\n\ + 3\n\x02\x04\x04\x12\x04T\0Z\x01\x1a'\x20Specifies\x20a\x20contiguous\x20\ + range\x20of\x20rows.\n\n\n\n\x03\x04\x04\x01\x12\x03T\x08\x10\nU\n\x04\ + \x04\x04\x02\0\x12\x03V\x02\x16\x1aH\x20Inclusive\x20lower\x20bound.\x20\ + If\x20left\x20empty,\x20interpreted\x20as\x20the\x20empty\x20string.\n\n\ + \r\n\x05\x04\x04\x02\0\x04\x12\x04V\x02T\x12\n\x0c\n\x05\x04\x04\x02\0\ + \x05\x12\x03V\x02\x07\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03V\x08\x11\n\ + \x0c\n\x05\x04\x04\x02\0\x03\x12\x03V\x14\x15\nM\n\x04\x04\x04\x02\x01\ + \x12\x03Y\x02\x14\x1a@\x20Exclusive\x20upper\x20bound.\x20If\x20left\x20\ + empty,\x20interpreted\x20as\x20infinity.\n\n\r\n\x05\x04\x04\x02\x01\x04\ + \x12\x04Y\x02V\x16\n\x0c\n\x05\x04\x04\x02\x01\x05\x12\x03Y\x02\x07\n\ + \x0c\n\x05\x04\x04\x02\x01\x01\x12\x03Y\x08\x0f\n\x0c\n\x05\x04\x04\x02\ + \x01\x03\x12\x03Y\x12\x13\n5\n\x02\x04\x05\x12\x04]\0c\x01\x1a)\x20Speci\ + fies\x20a\x20non-contiguous\x20set\x20of\x20rows.\n\n\n\n\x03\x04\x05\ + \x01\x12\x03]\x08\x0e\n/\n\x04\x04\x05\x02\0\x12\x03_\x02\x1e\x1a\"\x20S\ + ingle\x20rows\x20included\x20in\x20the\x20set.\n\n\x0c\n\x05\x04\x05\x02\ + \0\x04\x12\x03_\x02\n\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03_\x0b\x10\n\ + \x0c\n\x05\x04\x05\x02\0\x01\x12\x03_\x11\x19\n\x0c\n\x05\x04\x05\x02\0\ + \x03\x12\x03_\x1c\x1d\n9\n\x04\x04\x05\x02\x01\x12\x03b\x02#\x1a,\x20Con\ + tiguous\x20row\x20ranges\x20included\x20in\x20the\x20set.\n\n\x0c\n\x05\ + \x04\x05\x02\x01\x04\x12\x03b\x02\n\n\x0c\n\x05\x04\x05\x02\x01\x06\x12\ + \x03b\x0b\x13\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03b\x14\x1e\n\x0c\n\ + \x05\x04\x05\x02\x01\x03\x12\x03b!\"\n\xec\x01\n\x02\x04\x06\x12\x05i\0\ + \x80\x01\x01\x1a\xde\x01\x20Specifies\x20a\x20contiguous\x20range\x20of\ + \x20columns\x20within\x20a\x20single\x20column\x20family.\n\x20The\x20ra\ + nge\x20spans\x20from\x20:\x20to\n\x20:,\x20where\x20both\x20bounds\x20can\x20be\ + \x20either\x20inclusive\x20or\n\x20exclusive.\n\n\n\n\x03\x04\x06\x01\ + \x12\x03i\x08\x13\nK\n\x04\x04\x06\x02\0\x12\x03k\x02\x19\x1a>\x20The\ + \x20name\x20of\x20the\x20column\x20family\x20within\x20which\x20this\x20\ + range\x20falls.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04k\x02i\x15\n\x0c\n\ + \x05\x04\x06\x02\0\x05\x12\x03k\x02\x08\n\x0c\n\x05\x04\x06\x02\0\x01\ + \x12\x03k\t\x14\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03k\x17\x18\n\xa1\x01\ + \n\x04\x04\x06\x08\0\x12\x04o\x02u\x03\x1a\x92\x01\x20The\x20column\x20q\ + ualifier\x20at\x20which\x20to\x20start\x20the\x20range\x20(within\x20'co\ + lumn_family').\n\x20If\x20neither\x20field\x20is\x20set,\x20interpreted\ + \x20as\x20the\x20empty\x20string,\x20inclusive.\n\n\x0c\n\x05\x04\x06\ + \x08\0\x01\x12\x03o\x08\x17\nG\n\x04\x04\x06\x02\x01\x12\x03q\x04(\x1a:\ + \x20Used\x20when\x20giving\x20an\x20inclusive\x20lower\x20bound\x20for\ + \x20the\x20range.\n\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03q\x04\t\n\x0c\ + \n\x05\x04\x06\x02\x01\x01\x12\x03q\n#\n\x0c\n\x05\x04\x06\x02\x01\x03\ + \x12\x03q&'\nG\n\x04\x04\x06\x02\x02\x12\x03t\x04(\x1a:\x20Used\x20when\ + \x20giving\x20an\x20exclusive\x20lower\x20bound\x20for\x20the\x20range.\ + \n\n\x0c\n\x05\x04\x06\x02\x02\x05\x12\x03t\x04\t\n\x0c\n\x05\x04\x06\ + \x02\x02\x01\x12\x03t\n#\n\x0c\n\x05\x04\x06\x02\x02\x03\x12\x03t&'\n\ + \xa2\x01\n\x04\x04\x06\x08\x01\x12\x04y\x02\x7f\x03\x1a\x93\x01\x20The\ + \x20column\x20qualifier\x20at\x20which\x20to\x20end\x20the\x20range\x20(\ + within\x20'column_family').\n\x20If\x20neither\x20field\x20is\x20set,\ + \x20interpreted\x20as\x20the\x20infinite\x20string,\x20exclusive.\n\n\ + \x0c\n\x05\x04\x06\x08\x01\x01\x12\x03y\x08\x15\nG\n\x04\x04\x06\x02\x03\ + \x12\x03{\x04&\x1a:\x20Used\x20when\x20giving\x20an\x20inclusive\x20uppe\ + r\x20bound\x20for\x20the\x20range.\n\n\x0c\n\x05\x04\x06\x02\x03\x05\x12\ + \x03{\x04\t\n\x0c\n\x05\x04\x06\x02\x03\x01\x12\x03{\n!\n\x0c\n\x05\x04\ + \x06\x02\x03\x03\x12\x03{$%\nG\n\x04\x04\x06\x02\x04\x12\x03~\x04&\x1a:\ + \x20Used\x20when\x20giving\x20an\x20exclusive\x20upper\x20bound\x20for\ + \x20the\x20range.\n\n\x0c\n\x05\x04\x06\x02\x04\x05\x12\x03~\x04\t\n\x0c\ + \n\x05\x04\x06\x02\x04\x01\x12\x03~\n!\n\x0c\n\x05\x04\x06\x02\x04\x03\ + \x12\x03~$%\nG\n\x02\x04\x07\x12\x06\x83\x01\0\x89\x01\x01\x1a9\x20Speci\ + fied\x20a\x20contiguous\x20range\x20of\x20microsecond\x20timestamps.\n\n\ + \x0b\n\x03\x04\x07\x01\x12\x04\x83\x01\x08\x16\nG\n\x04\x04\x07\x02\0\ + \x12\x04\x85\x01\x02#\x1a9\x20Inclusive\x20lower\x20bound.\x20If\x20left\ + \x20empty,\x20interpreted\x20as\x200.\n\n\x0f\n\x05\x04\x07\x02\0\x04\ + \x12\x06\x85\x01\x02\x83\x01\x18\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\x85\ + \x01\x02\x07\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\x85\x01\x08\x1e\n\r\n\ + \x05\x04\x07\x02\0\x03\x12\x04\x85\x01!\"\nN\n\x04\x04\x07\x02\x01\x12\ + \x04\x88\x01\x02!\x1a@\x20Exclusive\x20upper\x20bound.\x20If\x20left\x20\ + empty,\x20interpreted\x20as\x20infinity.\n\n\x0f\n\x05\x04\x07\x02\x01\ + \x04\x12\x06\x88\x01\x02\x85\x01#\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\ + \x88\x01\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x88\x01\x08\x1c\n\ + \r\n\x05\x04\x07\x02\x01\x03\x12\x04\x88\x01\x1f\x20\n@\n\x02\x04\x08\ + \x12\x06\x8c\x01\0\xa0\x01\x01\x1a2\x20Specifies\x20a\x20contiguous\x20r\ + ange\x20of\x20raw\x20byte\x20values.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\ + \x8c\x01\x08\x12\n~\n\x04\x04\x08\x08\0\x12\x06\x8f\x01\x02\x95\x01\x03\ + \x1an\x20The\x20value\x20at\x20which\x20to\x20start\x20the\x20range.\n\ + \x20If\x20neither\x20field\x20is\x20set,\x20interpreted\x20as\x20the\x20\ + empty\x20string,\x20inclusive.\n\n\r\n\x05\x04\x08\x08\0\x01\x12\x04\x8f\ + \x01\x08\x13\nH\n\x04\x04\x08\x02\0\x12\x04\x91\x01\x04$\x1a:\x20Used\ + \x20when\x20giving\x20an\x20inclusive\x20lower\x20bound\x20for\x20the\ + \x20range.\n\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\x91\x01\x04\t\n\r\n\x05\ + \x04\x08\x02\0\x01\x12\x04\x91\x01\n\x1f\n\r\n\x05\x04\x08\x02\0\x03\x12\ + \x04\x91\x01\"#\nH\n\x04\x04\x08\x02\x01\x12\x04\x94\x01\x04$\x1a:\x20Us\ + ed\x20when\x20giving\x20an\x20exclusive\x20lower\x20bound\x20for\x20the\ + \x20range.\n\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\x94\x01\x04\t\n\r\n\ + \x05\x04\x08\x02\x01\x01\x12\x04\x94\x01\n\x1f\n\r\n\x05\x04\x08\x02\x01\ + \x03\x12\x04\x94\x01\"#\n\x7f\n\x04\x04\x08\x08\x01\x12\x06\x99\x01\x02\ + \x9f\x01\x03\x1ao\x20The\x20value\x20at\x20which\x20to\x20end\x20the\x20\ + range.\n\x20If\x20neither\x20field\x20is\x20set,\x20interpreted\x20as\ + \x20the\x20infinite\x20string,\x20exclusive.\n\n\r\n\x05\x04\x08\x08\x01\ + \x01\x12\x04\x99\x01\x08\x11\nH\n\x04\x04\x08\x02\x02\x12\x04\x9b\x01\ + \x04\"\x1a:\x20Used\x20when\x20giving\x20an\x20inclusive\x20upper\x20bou\ + nd\x20for\x20the\x20range.\n\n\r\n\x05\x04\x08\x02\x02\x05\x12\x04\x9b\ + \x01\x04\t\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\x9b\x01\n\x1d\n\r\n\x05\ + \x04\x08\x02\x02\x03\x12\x04\x9b\x01\x20!\nH\n\x04\x04\x08\x02\x03\x12\ + \x04\x9e\x01\x04\"\x1a:\x20Used\x20when\x20giving\x20an\x20exclusive\x20\ + upper\x20bound\x20for\x20the\x20range.\n\n\r\n\x05\x04\x08\x02\x03\x05\ + \x12\x04\x9e\x01\x04\t\n\r\n\x05\x04\x08\x02\x03\x01\x12\x04\x9e\x01\n\ + \x1d\n\r\n\x05\x04\x08\x02\x03\x03\x12\x04\x9e\x01\x20!\n\xa5\x0f\n\x02\ + \x04\t\x12\x06\xc3\x01\0\xa5\x03\x01\x1a\x96\x0f\x20Takes\x20a\x20row\ + \x20as\x20input\x20and\x20produces\x20an\x20alternate\x20view\x20of\x20t\ + he\x20row\x20based\x20on\n\x20specified\x20rules.\x20For\x20example,\x20\ + a\x20RowFilter\x20might\x20trim\x20down\x20a\x20row\x20to\x20include\n\ + \x20just\x20the\x20cells\x20from\x20columns\x20matching\x20a\x20given\ + \x20regular\x20expression,\x20or\x20might\n\x20return\x20all\x20the\x20c\ + ells\x20of\x20a\x20row\x20but\x20not\x20their\x20values.\x20More\x20comp\ + licated\x20filters\n\x20can\x20be\x20composed\x20out\x20of\x20these\x20c\ + omponents\x20to\x20express\x20requests\x20such\x20as,\x20\"within\n\x20e\ + very\x20column\x20of\x20a\x20particular\x20family,\x20give\x20just\x20th\ + e\x20two\x20most\x20recent\x20cells\n\x20which\x20are\x20older\x20than\ + \x20timestamp\x20X.\"\n\n\x20There\x20are\x20two\x20broad\x20categories\ + \x20of\x20RowFilters\x20(true\x20filters\x20and\x20transformers),\n\x20a\ + s\x20well\x20as\x20two\x20ways\x20to\x20compose\x20simple\x20filters\x20\ + into\x20more\x20complex\x20ones\n\x20(chains\x20and\x20interleaves).\x20\ + They\x20work\x20as\x20follows:\n\n\x20*\x20True\x20filters\x20alter\x20t\ + he\x20input\x20row\x20by\x20excluding\x20some\x20of\x20its\x20cells\x20w\ + holesale\n\x20from\x20the\x20output\x20row.\x20An\x20example\x20of\x20a\ + \x20true\x20filter\x20is\x20the\x20\"value_regex_filter\",\n\x20which\ + \x20excludes\x20cells\x20whose\x20values\x20don't\x20match\x20the\x20spe\ + cified\x20pattern.\x20All\n\x20regex\x20true\x20filters\x20use\x20RE2\ + \x20syntax\x20(https://github.com/google/re2/wiki/Syntax)\n\x20in\x20raw\ + \x20byte\x20mode\x20(RE2::Latin1),\x20and\x20are\x20evaluated\x20as\x20f\ + ull\x20matches.\x20An\n\x20important\x20point\x20to\x20keep\x20in\x20min\ + d\x20is\x20that\x20RE2(.)\x20is\x20equivalent\x20by\x20default\x20to\n\ + \x20RE2([^\\n]),\x20meaning\x20that\x20it\x20does\x20not\x20match\x20new\ + lines.\x20When\x20attempting\x20to\x20match\n\x20an\x20arbitrary\x20byte\ + ,\x20you\x20should\x20therefore\x20use\x20the\x20escape\x20sequence\x20'\ + \\C',\x20which\n\x20may\x20need\x20to\x20be\x20further\x20escaped\x20as\ + \x20'\\\\C'\x20in\x20your\x20client\x20language.\n\n\x20*\x20Transformer\ + s\x20alter\x20the\x20input\x20row\x20by\x20changing\x20the\x20values\x20\ + of\x20some\x20of\x20its\n\x20cells\x20in\x20the\x20output,\x20without\ + \x20excluding\x20them\x20completely.\x20Currently,\x20the\x20only\n\x20s\ + upported\x20transformer\x20is\x20the\x20\"strip_value_transformer\",\x20\ + which\x20replaces\x20every\n\x20cell's\x20value\x20with\x20the\x20empty\ + \x20string.\n\n\x20*\x20Chains\x20and\x20interleaves\x20are\x20described\ + \x20in\x20more\x20detail\x20in\x20the\n\x20RowFilter.Chain\x20and\x20Row\ + Filter.Interleave\x20documentation.\n\n\x20The\x20total\x20serialized\ + \x20size\x20of\x20a\x20RowFilter\x20message\x20must\x20not\n\x20exceed\ + \x204096\x20bytes,\x20and\x20RowFilters\x20may\x20not\x20be\x20nested\ + \x20within\x20each\x20other\n\x20(in\x20Chains\x20or\x20Interleaves)\x20\ + to\x20a\x20depth\x20of\x20more\x20than\x2020.\n\n\x0b\n\x03\x04\t\x01\ + \x12\x04\xc3\x01\x08\x11\nV\n\x04\x04\t\x03\0\x12\x06\xc5\x01\x02\xca\ + \x01\x03\x1aF\x20A\x20RowFilter\x20which\x20sends\x20rows\x20through\x20\ + several\x20RowFilters\x20in\x20sequence.\n\n\r\n\x05\x04\t\x03\0\x01\x12\ + \x04\xc5\x01\n\x0f\n\xc9\x01\n\x06\x04\t\x03\0\x02\0\x12\x04\xc9\x01\x04\ + #\x1a\xb8\x01\x20The\x20elements\x20of\x20\"filters\"\x20are\x20chained\ + \x20together\x20to\x20process\x20the\x20input\x20row:\n\x20in\x20row\x20\ + ->\x20f(0)\x20->\x20intermediate\x20row\x20->\x20f(1)\x20->\x20...\x20->\ + \x20f(N)\x20->\x20out\x20row\n\x20The\x20full\x20chain\x20is\x20executed\ + \x20atomically.\n\n\x0f\n\x07\x04\t\x03\0\x02\0\x04\x12\x04\xc9\x01\x04\ + \x0c\n\x0f\n\x07\x04\t\x03\0\x02\0\x06\x12\x04\xc9\x01\r\x16\n\x0f\n\x07\ + \x04\t\x03\0\x02\0\x01\x12\x04\xc9\x01\x17\x1e\n\x0f\n\x07\x04\t\x03\0\ + \x02\0\x03\x12\x04\xc9\x01!\"\nx\n\x04\x04\t\x03\x01\x12\x06\xce\x01\x02\ + \xe8\x01\x03\x1ah\x20A\x20RowFilter\x20which\x20sends\x20each\x20row\x20\ + to\x20each\x20of\x20several\x20component\n\x20RowFilters\x20and\x20inter\ + leaves\x20the\x20results.\n\n\r\n\x05\x04\t\x03\x01\x01\x12\x04\xce\x01\ + \n\x14\n\xe2\n\n\x06\x04\t\x03\x01\x02\0\x12\x04\xe7\x01\x04#\x1a\xd1\n\ + \x20The\x20elements\x20of\x20\"filters\"\x20all\x20process\x20a\x20copy\ + \x20of\x20the\x20input\x20row,\x20and\x20the\n\x20results\x20are\x20pool\ + ed,\x20sorted,\x20and\x20combined\x20into\x20a\x20single\x20output\x20ro\ + w.\n\x20If\x20multiple\x20cells\x20are\x20produced\x20with\x20the\x20sam\ + e\x20column\x20and\x20timestamp,\n\x20they\x20will\x20all\x20appear\x20i\ + n\x20the\x20output\x20row\x20in\x20an\x20unspecified\x20mutual\x20order.\ + \n\x20Consider\x20the\x20following\x20example,\x20with\x20three\x20filte\ + rs:\n\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20input\x20row\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\ + \x20\x20\x20\x20\x20\x20\x20--------------------------------------------\ + ---------\n\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + |\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20f(0)\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20f(1)\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20f(2)\n\x20\x20\x20\x20\x20\x20\x20\x20|\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x201:\ + \x20foo,bar,10,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20foo,\ + bar,10,z\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,bar,\ + 7,a\n\x202:\x20foo,blah,11,z\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20far,blah,5,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + far,blah,5,x\n\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20-\ + ----------------------------------------------------\n\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x201:\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20foo,bar,10,z\x20\x20\x20\x20\x20//\x20could\x20have\x20switc\ + hed\x20with\x20#2\n\x202:\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20foo,bar,10,x\x20\x20\ + \x20\x20\x20//\x20could\x20have\x20switched\x20with\x20#1\n\x203:\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20foo,blah,11,z\n\x204:\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,\ + bar,7,a\n\x205:\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,blah,5,x\x20\x20\x20\x20\x20\ + //\x20identical\x20to\x20#6\n\x206:\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,blah,5,x\ + \x20\x20\x20\x20\x20//\x20identical\x20to\x20#5\n\x20All\x20interleaved\ + \x20filters\x20are\x20executed\x20atomically.\n\n\x0f\n\x07\x04\t\x03\ + \x01\x02\0\x04\x12\x04\xe7\x01\x04\x0c\n\x0f\n\x07\x04\t\x03\x01\x02\0\ + \x06\x12\x04\xe7\x01\r\x16\n\x0f\n\x07\x04\t\x03\x01\x02\0\x01\x12\x04\ + \xe7\x01\x17\x1e\n\x0f\n\x07\x04\t\x03\x01\x02\0\x03\x12\x04\xe7\x01!\"\ + \n\xb4\x03\n\x04\x04\t\x03\x02\x12\x06\xf1\x01\x02\xfe\x01\x03\x1a\xa3\ + \x03\x20A\x20RowFilter\x20which\x20evaluates\x20one\x20of\x20two\x20poss\ + ible\x20RowFilters,\x20depending\x20on\n\x20whether\x20or\x20not\x20a\ + \x20predicate\x20RowFilter\x20outputs\x20any\x20cells\x20from\x20the\x20\ + input\x20row.\n\n\x20IMPORTANT\x20NOTE:\x20The\x20predicate\x20filter\ + \x20does\x20not\x20execute\x20atomically\x20with\x20the\n\x20true\x20and\ + \x20false\x20filters,\x20which\x20may\x20lead\x20to\x20inconsistent\x20o\ + r\x20unexpected\n\x20results.\x20Additionally,\x20Condition\x20filters\ + \x20have\x20poor\x20performance,\x20especially\n\x20when\x20filters\x20a\ + re\x20set\x20for\x20the\x20false\x20condition.\n\n\r\n\x05\x04\t\x03\x02\ + \x01\x12\x04\xf1\x01\n\x13\n\xa0\x01\n\x06\x04\t\x03\x02\x02\0\x12\x04\ + \xf4\x01\x04#\x1a\x8f\x01\x20If\x20\"predicate_filter\"\x20outputs\x20an\ + y\x20cells,\x20then\x20\"true_filter\"\x20will\x20be\n\x20evaluated\x20o\ + n\x20the\x20input\x20row.\x20Otherwise,\x20\"false_filter\"\x20will\x20b\ + e\x20evaluated.\n\n\x11\n\x07\x04\t\x03\x02\x02\0\x04\x12\x06\xf4\x01\ + \x04\xf1\x01\x15\n\x0f\n\x07\x04\t\x03\x02\x02\0\x06\x12\x04\xf4\x01\x04\ + \r\n\x0f\n\x07\x04\t\x03\x02\x02\0\x01\x12\x04\xf4\x01\x0e\x1e\n\x0f\n\ + \x07\x04\t\x03\x02\x02\0\x03\x12\x04\xf4\x01!\"\n\xa2\x01\n\x06\x04\t\ + \x03\x02\x02\x01\x12\x04\xf8\x01\x04\x1e\x1a\x91\x01\x20The\x20filter\ + \x20to\x20apply\x20to\x20the\x20input\x20row\x20if\x20\"predicate_filter\ + \"\x20returns\x20any\n\x20results.\x20If\x20not\x20provided,\x20no\x20re\ + sults\x20will\x20be\x20returned\x20in\x20the\x20true\x20case.\n\n\x11\n\ + \x07\x04\t\x03\x02\x02\x01\x04\x12\x06\xf8\x01\x04\xf4\x01#\n\x0f\n\x07\ + \x04\t\x03\x02\x02\x01\x06\x12\x04\xf8\x01\x04\r\n\x0f\n\x07\x04\t\x03\ + \x02\x02\x01\x01\x12\x04\xf8\x01\x0e\x19\n\x0f\n\x07\x04\t\x03\x02\x02\ + \x01\x03\x12\x04\xf8\x01\x1c\x1d\n\xac\x01\n\x06\x04\t\x03\x02\x02\x02\ + \x12\x04\xfd\x01\x04\x1f\x1a\x9b\x01\x20The\x20filter\x20to\x20apply\x20\ + to\x20the\x20input\x20row\x20if\x20\"predicate_filter\"\x20does\x20not\n\ + \x20return\x20any\x20results.\x20If\x20not\x20provided,\x20no\x20results\ + \x20will\x20be\x20returned\x20in\x20the\n\x20false\x20case.\n\n\x11\n\ + \x07\x04\t\x03\x02\x02\x02\x04\x12\x06\xfd\x01\x04\xf8\x01\x1e\n\x0f\n\ + \x07\x04\t\x03\x02\x02\x02\x06\x12\x04\xfd\x01\x04\r\n\x0f\n\x07\x04\t\ + \x03\x02\x02\x02\x01\x12\x04\xfd\x01\x0e\x1a\n\x0f\n\x07\x04\t\x03\x02\ + \x02\x02\x03\x12\x04\xfd\x01\x1d\x1e\n\x86\x01\n\x04\x04\t\x08\0\x12\x06\ + \x82\x02\x02\xa4\x03\x03\x1av\x20Which\x20of\x20the\x20possible\x20RowFi\ + lter\x20types\x20to\x20apply.\x20If\x20none\x20are\x20set,\x20this\n\x20\ + RowFilter\x20returns\x20all\x20cells\x20in\x20the\x20input\x20row.\n\n\r\ + \n\x05\x04\t\x08\0\x01\x12\x04\x82\x02\x08\x0e\ni\n\x04\x04\t\x02\0\x12\ + \x04\x85\x02\x04\x14\x1a[\x20Applies\x20several\x20RowFilters\x20to\x20t\ + he\x20data\x20in\x20sequence,\x20progressively\n\x20narrowing\x20the\x20\ + results.\n\n\r\n\x05\x04\t\x02\0\x06\x12\x04\x85\x02\x04\t\n\r\n\x05\x04\ + \t\x02\0\x01\x12\x04\x85\x02\n\x0f\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x85\ + \x02\x12\x13\n]\n\x04\x04\t\x02\x01\x12\x04\x89\x02\x04\x1e\x1aO\x20Appl\ + ies\x20several\x20RowFilters\x20to\x20the\x20data\x20in\x20parallel\x20a\ + nd\x20combines\x20the\n\x20results.\n\n\r\n\x05\x04\t\x02\x01\x06\x12\ + \x04\x89\x02\x04\x0e\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\x89\x02\x0f\x19\ + \n\r\n\x05\x04\t\x02\x01\x03\x12\x04\x89\x02\x1c\x1d\nq\n\x04\x04\t\x02\ + \x02\x12\x04\x8d\x02\x04\x1c\x1ac\x20Applies\x20one\x20of\x20two\x20poss\ + ible\x20RowFilters\x20to\x20the\x20data\x20based\x20on\x20the\x20output\ + \x20of\n\x20a\x20predicate\x20RowFilter.\n\n\r\n\x05\x04\t\x02\x02\x06\ + \x12\x04\x8d\x02\x04\r\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\x8d\x02\x0e\ + \x17\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\x8d\x02\x1a\x1b\n\x97\x14\n\x04\ + \x04\t\x02\x03\x12\x04\xca\x02\x04\x13\x1a\x88\x14\x20ADVANCED\x20USE\ + \x20ONLY.\n\x20Hook\x20for\x20introspection\x20into\x20the\x20RowFilter.\ + \x20Outputs\x20all\x20cells\x20directly\x20to\n\x20the\x20output\x20of\ + \x20the\x20read\x20rather\x20than\x20to\x20any\x20parent\x20filter.\x20C\ + onsider\x20the\n\x20following\x20example:\n\n\x20Chain(\n\x20\x20\x20Fam\ + ilyRegex(\"A\"),\n\x20\x20\x20Interleave(\n\x20\x20\x20\x20\x20All(),\n\ + \x20\x20\x20\x20\x20Chain(Label(\"foo\"),\x20Sink())\n\x20\x20\x20),\n\ + \x20\x20\x20QualifierRegex(\"B\")\n\x20)\n\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + A,A,1,w\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20B,B,4,z\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20FamilyRegex(\"A\")\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20A,A,1,w\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x\ + \n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20+------------+-------------+\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20All()\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20Label(foo)\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20A,A,1,w\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20A,A,1,w,labels:[foo]\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20A,B,2,x,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20Sink()\x20--------------+\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + |\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20+--------\ + ----+\x20\x20\x20\x20\x20\x20x------+\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20A,A,1,w,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + |\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20A,B,2,x,labels:[foo]\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20A,A,1,w\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + |\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20QualifierRegex(\"B\")\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20+-----------\ + ---------------------+\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20A,A,1,w,labels:[foo]\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20A,B,2,x,labels:[foo]\x20\x20//\x20could\x20be\x20switched\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20//\x20could\x20be\x20switched\n\n\x20Despite\x20being\ + \x20excluded\x20by\x20the\x20qualifier\x20filter,\x20a\x20copy\x20of\x20\ + every\x20cell\n\x20that\x20reaches\x20the\x20sink\x20is\x20present\x20in\ + \x20the\x20final\x20result.\n\n\x20As\x20with\x20an\x20[Interleave][goog\ + le.bigtable.v1.RowFilter.Interleave],\n\x20duplicate\x20cells\x20are\x20\ + possible,\x20and\x20appear\x20in\x20an\x20unspecified\x20mutual\x20order\ + .\n\x20In\x20this\x20case\x20we\x20have\x20a\x20duplicate\x20with\x20col\ + umn\x20\"A:B\"\x20and\x20timestamp\x202,\n\x20because\x20one\x20copy\x20\ + passed\x20through\x20the\x20all\x20filter\x20while\x20the\x20other\x20wa\ + s\n\x20passed\x20through\x20the\x20label\x20and\x20sink.\x20Note\x20that\ + \x20one\x20copy\x20has\x20label\x20\"foo\",\n\x20while\x20the\x20other\ + \x20does\x20not.\n\n\x20Cannot\x20be\x20used\x20within\x20the\x20`predic\ + ate_filter`,\x20`true_filter`,\x20or\n\x20`false_filter`\x20of\x20a\x20[\ + Condition][google.bigtable.v1.RowFilter.Condition].\n\n\r\n\x05\x04\t\ + \x02\x03\x05\x12\x04\xca\x02\x04\x08\n\r\n\x05\x04\t\x02\x03\x01\x12\x04\ + \xca\x02\t\r\n\r\n\x05\x04\t\x02\x03\x03\x12\x04\xca\x02\x10\x12\n\x8a\ + \x01\n\x04\x04\t\x02\x04\x12\x04\xce\x02\x04\x1e\x1a|\x20Matches\x20all\ + \x20cells,\x20regardless\x20of\x20input.\x20Functionally\x20equivalent\ + \x20to\n\x20leaving\x20`filter`\x20unset,\x20but\x20included\x20for\x20c\ + ompleteness.\n\n\r\n\x05\x04\t\x02\x04\x05\x12\x04\xce\x02\x04\x08\n\r\n\ + \x05\x04\t\x02\x04\x01\x12\x04\xce\x02\t\x18\n\r\n\x05\x04\t\x02\x04\x03\ + \x12\x04\xce\x02\x1b\x1d\nw\n\x04\x04\t\x02\x05\x12\x04\xd2\x02\x04\x1f\ + \x1ai\x20Does\x20not\x20match\x20any\x20cells,\x20regardless\x20of\x20in\ + put.\x20Useful\x20for\x20temporarily\n\x20disabling\x20just\x20part\x20o\ + f\x20a\x20filter.\n\n\r\n\x05\x04\t\x02\x05\x05\x12\x04\xd2\x02\x04\x08\ + \n\r\n\x05\x04\t\x02\x05\x01\x12\x04\xd2\x02\t\x19\n\r\n\x05\x04\t\x02\ + \x05\x03\x12\x04\xd2\x02\x1c\x1e\n\xa4\x03\n\x04\x04\t\x02\x06\x12\x04\ + \xdb\x02\x04#\x1a\x95\x03\x20Matches\x20only\x20cells\x20from\x20rows\ + \x20whose\x20keys\x20satisfy\x20the\x20given\x20RE2\x20regex.\x20In\n\ + \x20other\x20words,\x20passes\x20through\x20the\x20entire\x20row\x20when\ + \x20the\x20key\x20matches,\x20and\n\x20otherwise\x20produces\x20an\x20em\ + pty\x20row.\n\x20Note\x20that,\x20since\x20row\x20keys\x20can\x20contain\ + \x20arbitrary\x20bytes,\x20the\x20'\\C'\x20escape\n\x20sequence\x20must\ + \x20be\x20used\x20if\x20a\x20true\x20wildcard\x20is\x20desired.\x20The\ + \x20'.'\x20character\n\x20will\x20not\x20match\x20the\x20new\x20line\x20\ + character\x20'\\n',\x20which\x20may\x20be\x20present\x20in\x20a\n\x20bin\ + ary\x20key.\n\n\r\n\x05\x04\t\x02\x06\x05\x12\x04\xdb\x02\x04\t\n\r\n\ + \x05\x04\t\x02\x06\x01\x12\x04\xdb\x02\n\x1e\n\r\n\x05\x04\t\x02\x06\x03\ + \x12\x04\xdb\x02!\"\ny\n\x04\x04\t\x02\x07\x12\x04\xdf\x02\x04\"\x1ak\ + \x20Matches\x20all\x20cells\x20from\x20a\x20row\x20with\x20probability\ + \x20p,\x20and\x20matches\x20no\x20cells\n\x20from\x20the\x20row\x20with\ + \x20probability\x201-p.\n\n\r\n\x05\x04\t\x02\x07\x05\x12\x04\xdf\x02\ + \x04\n\n\r\n\x05\x04\t\x02\x07\x01\x12\x04\xdf\x02\x0b\x1c\n\r\n\x05\x04\ + \t\x02\x07\x03\x12\x04\xdf\x02\x1f!\n\xf0\x02\n\x04\x04\t\x02\x08\x12\ + \x04\xe7\x02\x04(\x1a\xe1\x02\x20Matches\x20only\x20cells\x20from\x20col\ + umns\x20whose\x20families\x20satisfy\x20the\x20given\x20RE2\n\x20regex.\ + \x20For\x20technical\x20reasons,\x20the\x20regex\x20must\x20not\x20conta\ + in\x20the\x20':'\n\x20character,\x20even\x20if\x20it\x20is\x20not\x20bei\ + ng\x20used\x20as\x20a\x20literal.\n\x20Note\x20that,\x20since\x20column\ + \x20families\x20cannot\x20contain\x20the\x20new\x20line\x20character\n\ + \x20'\\n',\x20it\x20is\x20sufficient\x20to\x20use\x20'.'\x20as\x20a\x20f\ + ull\x20wildcard\x20when\x20matching\n\x20column\x20family\x20names.\n\n\ + \r\n\x05\x04\t\x02\x08\x05\x12\x04\xe7\x02\x04\n\n\r\n\x05\x04\t\x02\x08\ + \x01\x12\x04\xe7\x02\x0b#\n\r\n\x05\x04\t\x02\x08\x03\x12\x04\xe7\x02&'\ + \n\xd2\x02\n\x04\x04\t\x02\t\x12\x04\xef\x02\x04,\x1a\xc3\x02\x20Matches\ + \x20only\x20cells\x20from\x20columns\x20whose\x20qualifiers\x20satisfy\ + \x20the\x20given\x20RE2\n\x20regex.\n\x20Note\x20that,\x20since\x20colum\ + n\x20qualifiers\x20can\x20contain\x20arbitrary\x20bytes,\x20the\x20'\\C'\ + \n\x20escape\x20sequence\x20must\x20be\x20used\x20if\x20a\x20true\x20wil\ + dcard\x20is\x20desired.\x20The\x20'.'\n\x20character\x20will\x20not\x20m\ + atch\x20the\x20new\x20line\x20character\x20'\\n',\x20which\x20may\x20be\ + \n\x20present\x20in\x20a\x20binary\x20qualifier.\n\n\r\n\x05\x04\t\x02\t\ + \x05\x12\x04\xef\x02\x04\t\n\r\n\x05\x04\t\x02\t\x01\x12\x04\xef\x02\n'\ + \n\r\n\x05\x04\t\x02\t\x03\x12\x04\xef\x02*+\nG\n\x04\x04\t\x02\n\x12\ + \x04\xf2\x02\x04(\x1a9\x20Matches\x20only\x20cells\x20from\x20columns\ + \x20within\x20the\x20given\x20range.\n\n\r\n\x05\x04\t\x02\n\x06\x12\x04\ + \xf2\x02\x04\x0f\n\r\n\x05\x04\t\x02\n\x01\x12\x04\xf2\x02\x10#\n\r\n\ + \x05\x04\t\x02\n\x03\x12\x04\xf2\x02&'\nJ\n\x04\x04\t\x02\x0b\x12\x04\ + \xf5\x02\x04.\x1a<\x20Matches\x20only\x20cells\x20with\x20timestamps\x20\ + within\x20the\x20given\x20range.\n\n\r\n\x05\x04\t\x02\x0b\x06\x12\x04\ + \xf5\x02\x04\x12\n\r\n\x05\x04\t\x02\x0b\x01\x12\x04\xf5\x02\x13)\n\r\n\ + \x05\x04\t\x02\x0b\x03\x12\x04\xf5\x02,-\n\xc3\x02\n\x04\x04\t\x02\x0c\ + \x12\x04\xfc\x02\x04!\x1a\xb4\x02\x20Matches\x20only\x20cells\x20with\ + \x20values\x20that\x20satisfy\x20the\x20given\x20regular\x20expression.\ + \n\x20Note\x20that,\x20since\x20cell\x20values\x20can\x20contain\x20arbi\ + trary\x20bytes,\x20the\x20'\\C'\x20escape\n\x20sequence\x20must\x20be\ + \x20used\x20if\x20a\x20true\x20wildcard\x20is\x20desired.\x20The\x20'.'\ + \x20character\n\x20will\x20not\x20match\x20the\x20new\x20line\x20charact\ + er\x20'\\n',\x20which\x20may\x20be\x20present\x20in\x20a\n\x20binary\x20\ + value.\n\n\r\n\x05\x04\t\x02\x0c\x05\x12\x04\xfc\x02\x04\t\n\r\n\x05\x04\ + \t\x02\x0c\x01\x12\x04\xfc\x02\n\x1c\n\r\n\x05\x04\t\x02\x0c\x03\x12\x04\ + \xfc\x02\x1f\x20\nP\n\x04\x04\t\x02\r\x12\x04\xff\x02\x04'\x1aB\x20Match\ + es\x20only\x20cells\x20with\x20values\x20that\x20fall\x20within\x20the\ + \x20given\x20range.\n\n\r\n\x05\x04\t\x02\r\x06\x12\x04\xff\x02\x04\x0e\ + \n\r\n\x05\x04\t\x02\r\x01\x12\x04\xff\x02\x0f!\n\r\n\x05\x04\t\x02\r\ + \x03\x12\x04\xff\x02$&\n\xcc\x01\n\x04\x04\t\x02\x0e\x12\x04\x84\x03\x04\ + +\x1a\xbd\x01\x20Skips\x20the\x20first\x20N\x20cells\x20of\x20each\x20ro\ + w,\x20matching\x20all\x20subsequent\x20cells.\n\x20If\x20duplicate\x20ce\ + lls\x20are\x20present,\x20as\x20is\x20possible\x20when\x20using\x20an\ + \x20Interleave,\n\x20each\x20copy\x20of\x20the\x20cell\x20is\x20counted\ + \x20separately.\n\n\r\n\x05\x04\t\x02\x0e\x05\x12\x04\x84\x03\x04\t\n\r\ + \n\x05\x04\t\x02\x0e\x01\x12\x04\x84\x03\n%\n\r\n\x05\x04\t\x02\x0e\x03\ + \x12\x04\x84\x03(*\n\xb4\x01\n\x04\x04\t\x02\x0f\x12\x04\x89\x03\x04*\ + \x1a\xa5\x01\x20Matches\x20only\x20the\x20first\x20N\x20cells\x20of\x20e\ + ach\x20row.\n\x20If\x20duplicate\x20cells\x20are\x20present,\x20as\x20is\ + \x20possible\x20when\x20using\x20an\x20Interleave,\n\x20each\x20copy\x20\ + of\x20the\x20cell\x20is\x20counted\x20separately.\n\n\r\n\x05\x04\t\x02\ + \x0f\x05\x12\x04\x89\x03\x04\t\n\r\n\x05\x04\t\x02\x0f\x01\x12\x04\x89\ + \x03\n$\n\r\n\x05\x04\t\x02\x0f\x03\x12\x04\x89\x03')\n\xf3\x02\n\x04\ + \x04\t\x02\x10\x12\x04\x91\x03\x04-\x1a\xe4\x02\x20Matches\x20only\x20th\ + e\x20most\x20recent\x20N\x20cells\x20within\x20each\x20column.\x20For\ + \x20example,\n\x20if\x20N=2,\x20this\x20filter\x20would\x20match\x20colu\ + mn\x20\"foo:bar\"\x20at\x20timestamps\x2010\x20and\x209,\n\x20skip\x20al\ + l\x20earlier\x20cells\x20in\x20\"foo:bar\",\x20and\x20then\x20begin\x20m\ + atching\x20again\x20in\n\x20column\x20\"foo:bar2\".\n\x20If\x20duplicate\ + \x20cells\x20are\x20present,\x20as\x20is\x20possible\x20when\x20using\ + \x20an\x20Interleave,\n\x20each\x20copy\x20of\x20the\x20cell\x20is\x20co\ + unted\x20separately.\n\n\r\n\x05\x04\t\x02\x10\x05\x12\x04\x91\x03\x04\t\ + \n\r\n\x05\x04\t\x02\x10\x01\x12\x04\x91\x03\n'\n\r\n\x05\x04\t\x02\x10\ + \x03\x12\x04\x91\x03*,\nA\n\x04\x04\t\x02\x11\x12\x04\x94\x03\x04&\x1a3\ + \x20Replaces\x20each\x20cell's\x20value\x20with\x20the\x20empty\x20strin\ + g.\n\n\r\n\x05\x04\t\x02\x11\x05\x12\x04\x94\x03\x04\x08\n\r\n\x05\x04\t\ + \x02\x11\x01\x12\x04\x94\x03\t\x20\n\r\n\x05\x04\t\x02\x11\x03\x12\x04\ + \x94\x03#%\n\xf5\x04\n\x04\x04\t\x02\x12\x12\x04\xa3\x03\x04(\x1a\xe6\ + \x04\x20Applies\x20the\x20given\x20label\x20to\x20all\x20cells\x20in\x20\ + the\x20output\x20row.\x20This\x20allows\n\x20the\x20client\x20to\x20dete\ + rmine\x20which\x20results\x20were\x20produced\x20from\x20which\x20part\ + \x20of\n\x20the\x20filter.\n\n\x20Values\x20must\x20be\x20at\x20most\x20\ + 15\x20characters\x20in\x20length,\x20and\x20match\x20the\x20RE2\n\x20pat\ + tern\x20[a-z0-9\\\\-]+\n\n\x20Due\x20to\x20a\x20technical\x20limitation,\ + \x20it\x20is\x20not\x20currently\x20possible\x20to\x20apply\n\x20multipl\ + e\x20labels\x20to\x20a\x20cell.\x20As\x20a\x20result,\x20a\x20Chain\x20m\ + ay\x20have\x20no\x20more\x20than\n\x20one\x20sub-filter\x20which\x20cont\ + ains\x20a\x20apply_label_transformer.\x20It\x20is\x20okay\x20for\n\x20an\ + \x20Interleave\x20to\x20contain\x20multiple\x20apply_label_transformers,\ + \x20as\x20they\x20will\n\x20be\x20applied\x20to\x20separate\x20copies\ + \x20of\x20the\x20input.\x20This\x20may\x20be\x20relaxed\x20in\x20the\n\ + \x20future.\n\n\r\n\x05\x04\t\x02\x12\x05\x12\x04\xa3\x03\x04\n\n\r\n\ + \x05\x04\t\x02\x12\x01\x12\x04\xa3\x03\x0b\"\n\r\n\x05\x04\t\x02\x12\x03\ + \x12\x04\xa3\x03%'\nR\n\x02\x04\n\x12\x06\xa8\x03\0\xe7\x03\x01\x1aD\x20\ + Specifies\x20a\x20particular\x20change\x20to\x20be\x20made\x20to\x20the\ + \x20contents\x20of\x20a\x20row.\n\n\x0b\n\x03\x04\n\x01\x12\x04\xa8\x03\ + \x08\x10\nH\n\x04\x04\n\x03\0\x12\x06\xaa\x03\x02\xbc\x03\x03\x1a8\x20A\ + \x20Mutation\x20which\x20sets\x20the\x20value\x20of\x20the\x20specified\ + \x20cell.\n\n\r\n\x05\x04\n\x03\0\x01\x12\x04\xaa\x03\n\x11\nk\n\x06\x04\ + \n\x03\0\x02\0\x12\x04\xad\x03\x04\x1b\x1a[\x20The\x20name\x20of\x20the\ + \x20family\x20into\x20which\x20new\x20data\x20should\x20be\x20written.\n\ + \x20Must\x20match\x20[-_.a-zA-Z0-9]+\n\n\x11\n\x07\x04\n\x03\0\x02\0\x04\ + \x12\x06\xad\x03\x04\xaa\x03\x13\n\x0f\n\x07\x04\n\x03\0\x02\0\x05\x12\ + \x04\xad\x03\x04\n\n\x0f\n\x07\x04\n\x03\0\x02\0\x01\x12\x04\xad\x03\x0b\ + \x16\n\x0f\n\x07\x04\n\x03\0\x02\0\x03\x12\x04\xad\x03\x19\x1a\n\x89\x01\ + \n\x06\x04\n\x03\0\x02\x01\x12\x04\xb1\x03\x04\x1f\x1ay\x20The\x20qualif\ + ier\x20of\x20the\x20column\x20into\x20which\x20new\x20data\x20should\x20\ + be\x20written.\n\x20Can\x20be\x20any\x20byte\x20string,\x20including\x20\ + the\x20empty\x20string.\n\n\x11\n\x07\x04\n\x03\0\x02\x01\x04\x12\x06\ + \xb1\x03\x04\xad\x03\x1b\n\x0f\n\x07\x04\n\x03\0\x02\x01\x05\x12\x04\xb1\ + \x03\x04\t\n\x0f\n\x07\x04\n\x03\0\x02\x01\x01\x12\x04\xb1\x03\n\x1a\n\ + \x0f\n\x07\x04\n\x03\0\x02\x01\x03\x12\x04\xb1\x03\x1d\x1e\n\xd3\x02\n\ + \x06\x04\n\x03\0\x02\x02\x12\x04\xb8\x03\x04\x1f\x1a\xc2\x02\x20The\x20t\ + imestamp\x20of\x20the\x20cell\x20into\x20which\x20new\x20data\x20should\ + \x20be\x20written.\n\x20Use\x20-1\x20for\x20current\x20Bigtable\x20serve\ + r\x20time.\n\x20Otherwise,\x20the\x20client\x20should\x20set\x20this\x20\ + value\x20itself,\x20noting\x20that\x20the\n\x20default\x20value\x20is\ + \x20a\x20timestamp\x20of\x20zero\x20if\x20the\x20field\x20is\x20left\x20\ + unspecified.\n\x20Values\x20must\x20match\x20the\x20\"granularity\"\x20o\ + f\x20the\x20table\x20(e.g.\x20micros,\x20millis).\n\n\x11\n\x07\x04\n\ + \x03\0\x02\x02\x04\x12\x06\xb8\x03\x04\xb1\x03\x1f\n\x0f\n\x07\x04\n\x03\ + \0\x02\x02\x05\x12\x04\xb8\x03\x04\t\n\x0f\n\x07\x04\n\x03\0\x02\x02\x01\ + \x12\x04\xb8\x03\n\x1a\n\x0f\n\x07\x04\n\x03\0\x02\x02\x03\x12\x04\xb8\ + \x03\x1d\x1e\nB\n\x06\x04\n\x03\0\x02\x03\x12\x04\xbb\x03\x04\x14\x1a2\ + \x20The\x20value\x20to\x20be\x20written\x20into\x20the\x20specified\x20c\ + ell.\n\n\x11\n\x07\x04\n\x03\0\x02\x03\x04\x12\x06\xbb\x03\x04\xb8\x03\ + \x1f\n\x0f\n\x07\x04\n\x03\0\x02\x03\x05\x12\x04\xbb\x03\x04\t\n\x0f\n\ + \x07\x04\n\x03\0\x02\x03\x01\x12\x04\xbb\x03\n\x0f\n\x0f\n\x07\x04\n\x03\ + \0\x02\x03\x03\x12\x04\xbb\x03\x12\x13\n\x8d\x01\n\x04\x04\n\x03\x01\x12\ + \x06\xc0\x03\x02\xcb\x03\x03\x1a}\x20A\x20Mutation\x20which\x20deletes\ + \x20cells\x20from\x20the\x20specified\x20column,\x20optionally\n\x20rest\ + ricting\x20the\x20deletions\x20to\x20a\x20given\x20timestamp\x20range.\n\ + \n\r\n\x05\x04\n\x03\x01\x01\x12\x04\xc0\x03\n\x1a\nh\n\x06\x04\n\x03\ + \x01\x02\0\x12\x04\xc3\x03\x04\x1b\x1aX\x20The\x20name\x20of\x20the\x20f\ + amily\x20from\x20which\x20cells\x20should\x20be\x20deleted.\n\x20Must\ + \x20match\x20[-_.a-zA-Z0-9]+\n\n\x11\n\x07\x04\n\x03\x01\x02\0\x04\x12\ + \x06\xc3\x03\x04\xc0\x03\x1c\n\x0f\n\x07\x04\n\x03\x01\x02\0\x05\x12\x04\ + \xc3\x03\x04\n\n\x0f\n\x07\x04\n\x03\x01\x02\0\x01\x12\x04\xc3\x03\x0b\ + \x16\n\x0f\n\x07\x04\n\x03\x01\x02\0\x03\x12\x04\xc3\x03\x19\x1a\n\x86\ + \x01\n\x06\x04\n\x03\x01\x02\x01\x12\x04\xc7\x03\x04\x1f\x1av\x20The\x20\ + qualifier\x20of\x20the\x20column\x20from\x20which\x20cells\x20should\x20\ + be\x20deleted.\n\x20Can\x20be\x20any\x20byte\x20string,\x20including\x20\ + the\x20empty\x20string.\n\n\x11\n\x07\x04\n\x03\x01\x02\x01\x04\x12\x06\ + \xc7\x03\x04\xc3\x03\x1b\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x05\x12\x04\ + \xc7\x03\x04\t\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x01\x12\x04\xc7\x03\n\ + \x1a\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x03\x12\x04\xc7\x03\x1d\x1e\nO\n\ + \x06\x04\n\x03\x01\x02\x02\x12\x04\xca\x03\x04\"\x1a?\x20The\x20range\ + \x20of\x20timestamps\x20within\x20which\x20cells\x20should\x20be\x20dele\ + ted.\n\n\x11\n\x07\x04\n\x03\x01\x02\x02\x04\x12\x06\xca\x03\x04\xc7\x03\ + \x1f\n\x0f\n\x07\x04\n\x03\x01\x02\x02\x06\x12\x04\xca\x03\x04\x12\n\x0f\ + \n\x07\x04\n\x03\x01\x02\x02\x01\x12\x04\xca\x03\x13\x1d\n\x0f\n\x07\x04\ + \n\x03\x01\x02\x02\x03\x12\x04\xca\x03\x20!\nV\n\x04\x04\n\x03\x02\x12\ + \x06\xce\x03\x02\xd2\x03\x03\x1aF\x20A\x20Mutation\x20which\x20deletes\ + \x20all\x20cells\x20from\x20the\x20specified\x20column\x20family.\n\n\r\ + \n\x05\x04\n\x03\x02\x01\x12\x04\xce\x03\n\x1a\nh\n\x06\x04\n\x03\x02\ + \x02\0\x12\x04\xd1\x03\x04\x1b\x1aX\x20The\x20name\x20of\x20the\x20famil\ + y\x20from\x20which\x20cells\x20should\x20be\x20deleted.\n\x20Must\x20mat\ + ch\x20[-_.a-zA-Z0-9]+\n\n\x11\n\x07\x04\n\x03\x02\x02\0\x04\x12\x06\xd1\ + \x03\x04\xce\x03\x1c\n\x0f\n\x07\x04\n\x03\x02\x02\0\x05\x12\x04\xd1\x03\ + \x04\n\n\x0f\n\x07\x04\n\x03\x02\x02\0\x01\x12\x04\xd1\x03\x0b\x16\n\x0f\ + \n\x07\x04\n\x03\x02\x02\0\x03\x12\x04\xd1\x03\x19\x1a\nM\n\x04\x04\n\ + \x03\x03\x12\x06\xd5\x03\x02\xd7\x03\x03\x1a=\x20A\x20Mutation\x20which\ + \x20deletes\x20all\x20cells\x20from\x20the\x20containing\x20row.\n\n\r\n\ + \x05\x04\n\x03\x03\x01\x12\x04\xd5\x03\n\x17\n@\n\x04\x04\n\x08\0\x12\ + \x06\xda\x03\x02\xe6\x03\x03\x1a0\x20Which\x20of\x20the\x20possible\x20M\ + utation\x20types\x20to\x20apply.\n\n\r\n\x05\x04\n\x08\0\x01\x12\x04\xda\ + \x03\x08\x10\n#\n\x04\x04\n\x02\0\x12\x04\xdc\x03\x04\x19\x1a\x15\x20Set\ + \x20a\x20cell's\x20value.\n\n\r\n\x05\x04\n\x02\0\x06\x12\x04\xdc\x03\ + \x04\x0b\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xdc\x03\x0c\x14\n\r\n\x05\x04\ + \n\x02\0\x03\x12\x04\xdc\x03\x17\x18\n,\n\x04\x04\n\x02\x01\x12\x04\xdf\ + \x03\x04,\x1a\x1e\x20Deletes\x20cells\x20from\x20a\x20column.\n\n\r\n\ + \x05\x04\n\x02\x01\x06\x12\x04\xdf\x03\x04\x14\n\r\n\x05\x04\n\x02\x01\ + \x01\x12\x04\xdf\x03\x15'\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xdf\x03*+\ + \n3\n\x04\x04\n\x02\x02\x12\x04\xe2\x03\x04,\x1a%\x20Deletes\x20cells\ + \x20from\x20a\x20column\x20family.\n\n\r\n\x05\x04\n\x02\x02\x06\x12\x04\ + \xe2\x03\x04\x14\n\r\n\x05\x04\n\x02\x02\x01\x12\x04\xe2\x03\x15'\n\r\n\ + \x05\x04\n\x02\x02\x03\x12\x04\xe2\x03*+\n2\n\x04\x04\n\x02\x03\x12\x04\ + \xe5\x03\x04&\x1a$\x20Deletes\x20cells\x20from\x20the\x20entire\x20row.\ + \n\n\r\n\x05\x04\n\x02\x03\x06\x12\x04\xe5\x03\x04\x11\n\r\n\x05\x04\n\ + \x02\x03\x01\x12\x04\xe5\x03\x12!\n\r\n\x05\x04\n\x02\x03\x03\x12\x04\ + \xe5\x03$%\nm\n\x02\x04\x0b\x12\x06\xeb\x03\0\x83\x04\x01\x1a_\x20Specif\ + ies\x20an\x20atomic\x20read/modify/write\x20operation\x20on\x20the\x20la\ + test\x20value\x20of\x20the\n\x20specified\x20column.\n\n\x0b\n\x03\x04\ + \x0b\x01\x12\x04\xeb\x03\x08\x1b\nt\n\x04\x04\x0b\x02\0\x12\x04\xee\x03\ + \x02\x19\x1af\x20The\x20name\x20of\x20the\x20family\x20to\x20which\x20th\ + e\x20read/modify/write\x20should\x20be\x20applied.\n\x20Must\x20match\ + \x20[-_.a-zA-Z0-9]+\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\xee\x03\x02\ + \xeb\x03\x1d\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\xee\x03\x02\x08\n\r\n\ + \x05\x04\x0b\x02\0\x01\x12\x04\xee\x03\t\x14\n\r\n\x05\x04\x0b\x02\0\x03\ + \x12\x04\xee\x03\x17\x18\n\x94\x01\n\x04\x04\x0b\x02\x01\x12\x04\xf3\x03\ + \x02\x1d\x1a\x85\x01\x20The\x20qualifier\x20of\x20the\x20column\x20to\ + \x20which\x20the\x20read/modify/write\x20should\x20be\n\x20applied.\n\ + \x20Can\x20be\x20any\x20byte\x20string,\x20including\x20the\x20empty\x20\ + string.\n\n\x0f\n\x05\x04\x0b\x02\x01\x04\x12\x06\xf3\x03\x02\xee\x03\ + \x19\n\r\n\x05\x04\x0b\x02\x01\x05\x12\x04\xf3\x03\x02\x07\n\r\n\x05\x04\ + \x0b\x02\x01\x01\x12\x04\xf3\x03\x08\x18\n\r\n\x05\x04\x0b\x02\x01\x03\ + \x12\x04\xf3\x03\x1b\x1c\nj\n\x04\x04\x0b\x08\0\x12\x06\xf7\x03\x02\x82\ + \x04\x03\x1aZ\x20The\x20rule\x20used\x20to\x20determine\x20the\x20column\ + 's\x20new\x20latest\x20value\x20from\x20its\x20current\n\x20latest\x20va\ + lue.\n\n\r\n\x05\x04\x0b\x08\0\x01\x12\x04\xf7\x03\x08\x0c\n\xab\x01\n\ + \x04\x04\x0b\x02\x02\x12\x04\xfb\x03\x04\x1b\x1a\x9c\x01\x20Rule\x20spec\ + ifying\x20that\x20\"append_value\"\x20be\x20appended\x20to\x20the\x20exi\ + sting\x20value.\n\x20If\x20the\x20targeted\x20cell\x20is\x20unset,\x20it\ + \x20will\x20be\x20treated\x20as\x20containing\x20the\n\x20empty\x20strin\ + g.\n\n\r\n\x05\x04\x0b\x02\x02\x05\x12\x04\xfb\x03\x04\t\n\r\n\x05\x04\ + \x0b\x02\x02\x01\x12\x04\xfb\x03\n\x16\n\r\n\x05\x04\x0b\x02\x02\x03\x12\ + \x04\xfb\x03\x19\x1a\n\xb3\x02\n\x04\x04\x0b\x02\x03\x12\x04\x81\x04\x04\ + \x1f\x1a\xa4\x02\x20Rule\x20specifying\x20that\x20\"increment_amount\"\ + \x20be\x20added\x20to\x20the\x20existing\x20value.\n\x20If\x20the\x20tar\ + geted\x20cell\x20is\x20unset,\x20it\x20will\x20be\x20treated\x20as\x20co\ + ntaining\x20a\x20zero.\n\x20Otherwise,\x20the\x20targeted\x20cell\x20mus\ + t\x20contain\x20an\x208-byte\x20value\x20(interpreted\n\x20as\x20a\x2064\ + -bit\x20big-endian\x20signed\x20integer),\x20or\x20the\x20entire\x20requ\ + est\x20will\x20fail.\n\n\r\n\x05\x04\x0b\x02\x03\x05\x12\x04\x81\x04\x04\ + \t\n\r\n\x05\x04\x0b\x02\x03\x01\x12\x04\x81\x04\n\x1a\n\r\n\x05\x04\x0b\ + \x02\x03\x03\x12\x04\x81\x04\x1d\x1eb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service.rs new file mode 100644 index 00000000..c8a9c08c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service.rs @@ -0,0 +1,142 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/v1/bigtable_service.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n)google/bigtable/v1/bigtable_service.proto\x12\x12google.bigtable.v1\ + \x1a\x1cgoogle/api/annotations.proto\x1a&google/bigtable/v1/bigtable_dat\ + a.proto\x1a2google/bigtable/v1/bigtable_service_messages.proto\x1a\x1bgo\ + ogle/protobuf/empty.proto2\xdd\x08\n\x0fBigtableService\x12\xa5\x01\n\ + \x08ReadRows\x12#.google.bigtable.v1.ReadRowsRequest\x1a$.google.bigtabl\ + e.v1.ReadRowsResponse\"L\x82\xd3\xe4\x93\x02F\"A/v1/{table_name=projects\ + /*/zones/*/clusters/*/tables/*}/rows:read:\x01*0\x01\x12\xb7\x01\n\rSamp\ + leRowKeys\x12(.google.bigtable.v1.SampleRowKeysRequest\x1a).google.bigta\ + ble.v1.SampleRowKeysResponse\"O\x82\xd3\xe4\x93\x02I\x12G/v1/{table_name\ + =projects/*/zones/*/clusters/*/tables/*}/rows:sampleKeys0\x01\x12\xa3\ + \x01\n\tMutateRow\x12$.google.bigtable.v1.MutateRowRequest\x1a\x16.googl\ + e.protobuf.Empty\"X\x82\xd3\xe4\x93\x02R\"M/v1/{table_name=projects/*/zo\ + nes/*/clusters/*/tables/*}/rows/{row_key}:mutate:\x01*\x12\xaa\x01\n\nMu\ + tateRows\x12%.google.bigtable.v1.MutateRowsRequest\x1a&.google.bigtable.\ + v1.MutateRowsResponse\"M\x82\xd3\xe4\x93\x02G\"B/v1/{table_name=projects\ + /*/zones/*/clusters/*/tables/*}:mutateRows:\x01*\x12\xd2\x01\n\x11CheckA\ + ndMutateRow\x12,.google.bigtable.v1.CheckAndMutateRowRequest\x1a-.google\ + .bigtable.v1.CheckAndMutateRowResponse\"`\x82\xd3\xe4\x93\x02Z\"U/v1/{ta\ + ble_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:checkAnd\ + Mutate:\x01*\x12\xbf\x01\n\x12ReadModifyWriteRow\x12-.google.bigtable.v1\ + .ReadModifyWriteRowRequest\x1a\x17.google.bigtable.v1.Row\"a\x82\xd3\xe4\ + \x93\x02[\"V/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows\ + /{row_key}:readModifyWrite:\x01*Bp\n\x16com.google.bigtable.v1B\x15Bigta\ + bleServicesProtoP\x01Z:google.golang.org/genproto/googleapis/bigtable/v1\ + ;bigtable\x88\x01\x01J\xb1\x13\n\x06\x12\x04\x0e\0Z\x01\n\xbd\x04\n\x01\ + \x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\ + \n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\ + \x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\ + \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\ + y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\ + \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\ + ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\ + \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\ + buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\ + \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\ + \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\ + guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\ + e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1b\n\t\n\x02\x03\0\x12\ + \x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\00\n\t\n\x02\x03\x02\x12\x03\ + \x14\0<\n\t\n\x02\x03\x03\x12\x03\x15\0%\n\x08\n\x01\x08\x12\x03\x17\0Q\ + \n\t\n\x02\x08\x0b\x12\x03\x17\0Q\n\x08\n\x01\x08\x12\x03\x18\0$\n\t\n\ + \x02\x08\x11\x12\x03\x18\0$\n\x08\n\x01\x08\x12\x03\x19\0\"\n\t\n\x02\ + \x08\n\x12\x03\x19\0\"\n\x08\n\x01\x08\x12\x03\x1a\06\n\t\n\x02\x08\x08\ + \x12\x03\x1a\06\n\x08\n\x01\x08\x12\x03\x1b\0/\n\t\n\x02\x08\x01\x12\x03\ + \x1b\0/\nI\n\x02\x06\0\x12\x04\x1f\0Z\x01\x1a=\x20Service\x20for\x20read\ + ing\x20from\x20and\x20writing\x20to\x20existing\x20Bigtables.\n\n\n\n\ + \x03\x06\0\x01\x12\x03\x1f\x08\x17\n\xf5\x01\n\x04\x06\0\x02\0\x12\x04$\ + \x02)\x03\x1a\xe6\x01\x20Streams\x20back\x20the\x20contents\x20of\x20all\ + \x20requested\x20rows,\x20optionally\x20applying\n\x20the\x20same\x20Rea\ + der\x20filter\x20to\x20each.\x20Depending\x20on\x20their\x20size,\x20row\ + s\x20may\x20be\n\x20broken\x20up\x20across\x20multiple\x20responses,\x20\ + but\x20atomicity\x20of\x20each\x20row\x20will\x20still\n\x20be\x20preser\ + ved.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03$\x06\x0e\n\x0c\n\x05\x06\0\ + \x02\0\x02\x12\x03$\x0f\x1e\n\x0c\n\x05\x06\0\x02\0\x06\x12\x03$)/\n\x0c\ + \n\x05\x06\0\x02\0\x03\x12\x03$0@\n\r\n\x05\x06\0\x02\0\x04\x12\x04%\x04\ + (\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04%\x04(\x06\n\xed\ + \x01\n\x04\x06\0\x02\x01\x12\x04/\x023\x03\x1a\xde\x01\x20Returns\x20a\ + \x20sample\x20of\x20row\x20keys\x20in\x20the\x20table.\x20The\x20returne\ + d\x20row\x20keys\x20will\n\x20delimit\x20contiguous\x20sections\x20of\ + \x20the\x20table\x20of\x20approximately\x20equal\x20size,\n\x20which\x20\ + can\x20be\x20used\x20to\x20break\x20up\x20the\x20data\x20for\x20distribu\ + ted\x20tasks\x20like\n\x20mapreduces.\n\n\x0c\n\x05\x06\0\x02\x01\x01\ + \x12\x03/\x06\x13\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03/\x14(\n\x0c\n\ + \x05\x06\0\x02\x01\x06\x12\x03/39\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03/\ + :O\n\r\n\x05\x06\0\x02\x01\x04\x12\x040\x042\x06\n\x11\n\t\x06\0\x02\x01\ + \x04\xb0\xca\xbc\"\x12\x040\x042\x06\n\x87\x01\n\x04\x06\0\x02\x02\x12\ + \x047\x02<\x03\x1ay\x20Mutates\x20a\x20row\x20atomically.\x20Cells\x20al\ + ready\x20present\x20in\x20the\x20row\x20are\x20left\n\x20unchanged\x20un\ + less\x20explicitly\x20changed\x20by\x20'mutation'.\n\n\x0c\n\x05\x06\0\ + \x02\x02\x01\x12\x037\x06\x0f\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x037\x10\ + \x20\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x037+@\n\r\n\x05\x06\0\x02\x02\ + \x04\x12\x048\x04;\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04\ + 8\x04;\x06\n\xa0\x01\n\x04\x06\0\x02\x03\x12\x04A\x02F\x03\x1a\x91\x01\ + \x20Mutates\x20multiple\x20rows\x20in\x20a\x20batch.\x20Each\x20individu\ + al\x20row\x20is\x20mutated\n\x20atomically\x20as\x20in\x20MutateRow,\x20\ + but\x20the\x20entire\x20batch\x20is\x20not\x20executed\n\x20atomically.\ + \n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03A\x06\x10\n\x0c\n\x05\x06\0\x02\ + \x03\x02\x12\x03A\x11\"\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03A-?\n\r\n\ + \x05\x06\0\x02\x03\x04\x12\x04B\x04E\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\ + \xca\xbc\"\x12\x04B\x04E\x06\nZ\n\x04\x06\0\x02\x04\x12\x04I\x02N\x03\ + \x1aL\x20Mutates\x20a\x20row\x20atomically\x20based\x20on\x20the\x20outp\ + ut\x20of\x20a\x20predicate\x20Reader\x20filter.\n\n\x0c\n\x05\x06\0\x02\ + \x04\x01\x12\x03I\x06\x17\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03I\x180\n\ + \x0c\n\x05\x06\0\x02\x04\x03\x12\x03I;T\n\r\n\x05\x06\0\x02\x04\x04\x12\ + \x04J\x04M\x06\n\x11\n\t\x06\0\x02\x04\x04\xb0\xca\xbc\"\x12\x04J\x04M\ + \x06\n\x9b\x02\n\x04\x06\0\x02\x05\x12\x04T\x02Y\x03\x1a\x8c\x02\x20Modi\ + fies\x20a\x20row\x20atomically,\x20reading\x20the\x20latest\x20existing\ + \x20timestamp/value\x20from\n\x20the\x20specified\x20columns\x20and\x20w\ + riting\x20a\x20new\x20value\x20at\n\x20max(existing\x20timestamp,\x20cur\ + rent\x20server\x20time)\x20based\x20on\x20pre-defined\n\x20read/modify/w\ + rite\x20rules.\x20Returns\x20the\x20new\x20contents\x20of\x20all\x20modi\ + fied\x20cells.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03T\x06\x18\n\x0c\n\ + \x05\x06\0\x02\x05\x02\x12\x03T\x192\n\x0c\n\x05\x06\0\x02\x05\x03\x12\ + \x03T=@\n\r\n\x05\x06\0\x02\x05\x04\x12\x04U\x04X\x06\n\x11\n\t\x06\0\ + \x02\x05\x04\xb0\xca\xbc\"\x12\x04U\x04X\x06b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_grpc.rs new file mode 100644 index 00000000..2297831b --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_grpc.rs @@ -0,0 +1,195 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_SERVICE_READ_ROWS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.bigtable.v1.BigtableService/ReadRows", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SERVICE_SAMPLE_ROW_KEYS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.bigtable.v1.BigtableService/SampleRowKeys", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SERVICE_MUTATE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v1.BigtableService/MutateRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SERVICE_MUTATE_ROWS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v1.BigtableService/MutateRows", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SERVICE_CHECK_AND_MUTATE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v1.BigtableService/CheckAndMutateRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SERVICE_READ_MODIFY_WRITE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v1.BigtableService/ReadModifyWriteRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableServiceClient { + client: ::grpcio::Client, +} + +impl BigtableServiceClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableServiceClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn read_rows_opt(&self, req: &super::bigtable_service_messages::ReadRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_BIGTABLE_SERVICE_READ_ROWS, req, opt) + } + + pub fn read_rows(&self, req: &super::bigtable_service_messages::ReadRowsRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.read_rows_opt(req, ::grpcio::CallOption::default()) + } + + pub fn sample_row_keys_opt(&self, req: &super::bigtable_service_messages::SampleRowKeysRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_BIGTABLE_SERVICE_SAMPLE_ROW_KEYS, req, opt) + } + + pub fn sample_row_keys(&self, req: &super::bigtable_service_messages::SampleRowKeysRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.sample_row_keys_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_row_opt(&self, req: &super::bigtable_service_messages::MutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_SERVICE_MUTATE_ROW, req, opt) + } + + pub fn mutate_row(&self, req: &super::bigtable_service_messages::MutateRowRequest) -> ::grpcio::Result { + self.mutate_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_row_async_opt(&self, req: &super::bigtable_service_messages::MutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_SERVICE_MUTATE_ROW, req, opt) + } + + pub fn mutate_row_async(&self, req: &super::bigtable_service_messages::MutateRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.mutate_row_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_rows_opt(&self, req: &super::bigtable_service_messages::MutateRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_SERVICE_MUTATE_ROWS, req, opt) + } + + pub fn mutate_rows(&self, req: &super::bigtable_service_messages::MutateRowsRequest) -> ::grpcio::Result { + self.mutate_rows_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_rows_async_opt(&self, req: &super::bigtable_service_messages::MutateRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_SERVICE_MUTATE_ROWS, req, opt) + } + + pub fn mutate_rows_async(&self, req: &super::bigtable_service_messages::MutateRowsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.mutate_rows_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_and_mutate_row_opt(&self, req: &super::bigtable_service_messages::CheckAndMutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_SERVICE_CHECK_AND_MUTATE_ROW, req, opt) + } + + pub fn check_and_mutate_row(&self, req: &super::bigtable_service_messages::CheckAndMutateRowRequest) -> ::grpcio::Result { + self.check_and_mutate_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_and_mutate_row_async_opt(&self, req: &super::bigtable_service_messages::CheckAndMutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_SERVICE_CHECK_AND_MUTATE_ROW, req, opt) + } + + pub fn check_and_mutate_row_async(&self, req: &super::bigtable_service_messages::CheckAndMutateRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.check_and_mutate_row_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_modify_write_row_opt(&self, req: &super::bigtable_service_messages::ReadModifyWriteRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_SERVICE_READ_MODIFY_WRITE_ROW, req, opt) + } + + pub fn read_modify_write_row(&self, req: &super::bigtable_service_messages::ReadModifyWriteRowRequest) -> ::grpcio::Result { + self.read_modify_write_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_modify_write_row_async_opt(&self, req: &super::bigtable_service_messages::ReadModifyWriteRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_SERVICE_READ_MODIFY_WRITE_ROW, req, opt) + } + + pub fn read_modify_write_row_async(&self, req: &super::bigtable_service_messages::ReadModifyWriteRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.read_modify_write_row_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait BigtableService { + fn read_rows(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::ReadRowsRequest, sink: ::grpcio::ServerStreamingSink); + fn sample_row_keys(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::SampleRowKeysRequest, sink: ::grpcio::ServerStreamingSink); + fn mutate_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::MutateRowRequest, sink: ::grpcio::UnarySink); + fn mutate_rows(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::MutateRowsRequest, sink: ::grpcio::UnarySink); + fn check_and_mutate_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::CheckAndMutateRowRequest, sink: ::grpcio::UnarySink); + fn read_modify_write_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable_service_messages::ReadModifyWriteRowRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable_service(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_BIGTABLE_SERVICE_READ_ROWS, move |ctx, req, resp| { + instance.read_rows(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_BIGTABLE_SERVICE_SAMPLE_ROW_KEYS, move |ctx, req, resp| { + instance.sample_row_keys(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_SERVICE_MUTATE_ROW, move |ctx, req, resp| { + instance.mutate_row(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_SERVICE_MUTATE_ROWS, move |ctx, req, resp| { + instance.mutate_rows(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_SERVICE_CHECK_AND_MUTATE_ROW, move |ctx, req, resp| { + instance.check_and_mutate_row(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_SERVICE_READ_MODIFY_WRITE_ROW, move |ctx, req, resp| { + instance.read_modify_write_row(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_messages.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_messages.rs new file mode 100644 index 00000000..a08c4736 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/bigtable_service_messages.rs @@ -0,0 +1,3447 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/v1/bigtable_service_messages.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsRequest { + // message fields + pub table_name: ::std::string::String, + pub filter: ::protobuf::SingularPtrField, + pub allow_row_interleaving: bool, + pub num_rows_limit: i64, + // message oneof groups + pub target: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsRequest { + fn default() -> &'a ReadRowsRequest { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ReadRowsRequest_oneof_target { + row_key(::std::vec::Vec), + row_range(super::bigtable_data::RowRange), + row_set(super::bigtable_data::RowSet), +} + +impl ReadRowsRequest { + pub fn new() -> ReadRowsRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(ref v)) => v, + _ => &[], + } + } + pub fn clear_row_key(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_row_key(&self) -> bool { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(::std::vec::Vec::new())); + } + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + if self.has_row_key() { + match self.target.take() { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.bigtable.v1.RowRange row_range = 3; + + + pub fn get_row_range(&self) -> &super::bigtable_data::RowRange { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(ref v)) => v, + _ => super::bigtable_data::RowRange::default_instance(), + } + } + pub fn clear_row_range(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_row_range(&self) -> bool { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_range(&mut self, v: super::bigtable_data::RowRange) { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_range(&mut self) -> &mut super::bigtable_data::RowRange { + if let ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(super::bigtable_data::RowRange::new())); + } + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_range(&mut self) -> super::bigtable_data::RowRange { + if self.has_row_range() { + match self.target.take() { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(v)) => v, + _ => panic!(), + } + } else { + super::bigtable_data::RowRange::new() + } + } + + // .google.bigtable.v1.RowSet row_set = 8; + + + pub fn get_row_set(&self) -> &super::bigtable_data::RowSet { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(ref v)) => v, + _ => super::bigtable_data::RowSet::default_instance(), + } + } + pub fn clear_row_set(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_row_set(&self) -> bool { + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_set(&mut self, v: super::bigtable_data::RowSet) { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_set(&mut self) -> &mut super::bigtable_data::RowSet { + if let ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(super::bigtable_data::RowSet::new())); + } + match self.target { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_set(&mut self) -> super::bigtable_data::RowSet { + if self.has_row_set() { + match self.target.take() { + ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(v)) => v, + _ => panic!(), + } + } else { + super::bigtable_data::RowSet::new() + } + } + + // .google.bigtable.v1.RowFilter filter = 5; + + + pub fn get_filter(&self) -> &super::bigtable_data::RowFilter { + self.filter.as_ref().unwrap_or_else(|| super::bigtable_data::RowFilter::default_instance()) + } + pub fn clear_filter(&mut self) { + self.filter.clear(); + } + + pub fn has_filter(&self) -> bool { + self.filter.is_some() + } + + // Param is passed by value, moved + pub fn set_filter(&mut self, v: super::bigtable_data::RowFilter) { + self.filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_filter(&mut self) -> &mut super::bigtable_data::RowFilter { + if self.filter.is_none() { + self.filter.set_default(); + } + self.filter.as_mut().unwrap() + } + + // Take field + pub fn take_filter(&mut self) -> super::bigtable_data::RowFilter { + self.filter.take().unwrap_or_else(|| super::bigtable_data::RowFilter::new()) + } + + // bool allow_row_interleaving = 6; + + + pub fn get_allow_row_interleaving(&self) -> bool { + self.allow_row_interleaving + } + pub fn clear_allow_row_interleaving(&mut self) { + self.allow_row_interleaving = false; + } + + // Param is passed by value, moved + pub fn set_allow_row_interleaving(&mut self, v: bool) { + self.allow_row_interleaving = v; + } + + // int64 num_rows_limit = 7; + + + pub fn get_num_rows_limit(&self) -> i64 { + self.num_rows_limit + } + pub fn clear_num_rows_limit(&mut self) { + self.num_rows_limit = 0; + } + + // Param is passed by value, moved + pub fn set_num_rows_limit(&mut self, v: i64) { + self.num_rows_limit = v; + } +} + +impl ::protobuf::Message for ReadRowsRequest { + fn is_initialized(&self) -> bool { + if let Some(ReadRowsRequest_oneof_target::row_range(ref v)) = self.target { + if !v.is_initialized() { + return false; + } + } + if let Some(ReadRowsRequest_oneof_target::row_set(ref v)) = self.target { + if !v.is_initialized() { + return false; + } + } + for v in &self.filter { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_key(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_range(is.read_message()?)); + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(ReadRowsRequest_oneof_target::row_set(is.read_message()?)); + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.filter)?; + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.allow_row_interleaving = tmp; + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.num_rows_limit = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if let Some(ref v) = self.filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.allow_row_interleaving != false { + my_size += 2; + } + if self.num_rows_limit != 0 { + my_size += ::protobuf::rt::value_size(7, self.num_rows_limit, ::protobuf::wire_format::WireTypeVarint); + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &ReadRowsRequest_oneof_target::row_key(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &ReadRowsRequest_oneof_target::row_range(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &ReadRowsRequest_oneof_target::row_set(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if let Some(ref v) = self.filter.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.allow_row_interleaving != false { + os.write_bool(6, self.allow_row_interleaving)?; + } + if self.num_rows_limit != 0 { + os.write_int64(7, self.num_rows_limit)?; + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &ReadRowsRequest_oneof_target::row_key(ref v) => { + os.write_bytes(2, v)?; + }, + &ReadRowsRequest_oneof_target::row_range(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &ReadRowsRequest_oneof_target::row_set(ref v) => { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsRequest { + ReadRowsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &ReadRowsRequest| { &m.table_name }, + |m: &mut ReadRowsRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "row_key", + ReadRowsRequest::has_row_key, + ReadRowsRequest::get_row_key, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::bigtable_data::RowRange>( + "row_range", + ReadRowsRequest::has_row_range, + ReadRowsRequest::get_row_range, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::bigtable_data::RowSet>( + "row_set", + ReadRowsRequest::has_row_set, + ReadRowsRequest::get_row_set, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filter", + |m: &ReadRowsRequest| { &m.filter }, + |m: &mut ReadRowsRequest| { &mut m.filter }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "allow_row_interleaving", + |m: &ReadRowsRequest| { &m.allow_row_interleaving }, + |m: &mut ReadRowsRequest| { &mut m.allow_row_interleaving }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "num_rows_limit", + |m: &ReadRowsRequest| { &m.num_rows_limit }, + |m: &mut ReadRowsRequest| { &mut m.num_rows_limit }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsRequest, + }; + unsafe { + instance.get(ReadRowsRequest::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.target = ::std::option::Option::None; + self.target = ::std::option::Option::None; + self.target = ::std::option::Option::None; + self.filter.clear(); + self.allow_row_interleaving = false; + self.num_rows_limit = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsResponse { + // message fields + pub row_key: ::std::vec::Vec, + pub chunks: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsResponse { + fn default() -> &'a ReadRowsResponse { + ::default_instance() + } +} + +impl ReadRowsResponse { + pub fn new() -> ReadRowsResponse { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.ReadRowsResponse.Chunk chunks = 2; + + + pub fn get_chunks(&self) -> &[ReadRowsResponse_Chunk] { + &self.chunks + } + pub fn clear_chunks(&mut self) { + self.chunks.clear(); + } + + // Param is passed by value, moved + pub fn set_chunks(&mut self, v: ::protobuf::RepeatedField) { + self.chunks = v; + } + + // Mutable pointer to the field. + pub fn mut_chunks(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.chunks + } + + // Take field + pub fn take_chunks(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.chunks, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ReadRowsResponse { + fn is_initialized(&self) -> bool { + for v in &self.chunks { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.chunks)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + for value in &self.chunks { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + for v in &self.chunks { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsResponse { + ReadRowsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &ReadRowsResponse| { &m.row_key }, + |m: &mut ReadRowsResponse| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "chunks", + |m: &ReadRowsResponse| { &m.chunks }, + |m: &mut ReadRowsResponse| { &mut m.chunks }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsResponse, + }; + unsafe { + instance.get(ReadRowsResponse::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsResponse { + fn clear(&mut self) { + self.row_key.clear(); + self.chunks.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsResponse_Chunk { + // message oneof groups + pub chunk: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsResponse_Chunk { + fn default() -> &'a ReadRowsResponse_Chunk { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ReadRowsResponse_Chunk_oneof_chunk { + row_contents(super::bigtable_data::Family), + reset_row(bool), + commit_row(bool), +} + +impl ReadRowsResponse_Chunk { + pub fn new() -> ReadRowsResponse_Chunk { + ::std::default::Default::default() + } + + // .google.bigtable.v1.Family row_contents = 1; + + + pub fn get_row_contents(&self) -> &super::bigtable_data::Family { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(ref v)) => v, + _ => super::bigtable_data::Family::default_instance(), + } + } + pub fn clear_row_contents(&mut self) { + self.chunk = ::std::option::Option::None; + } + + pub fn has_row_contents(&self) -> bool { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_contents(&mut self, v: super::bigtable_data::Family) { + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_contents(&mut self) -> &mut super::bigtable_data::Family { + if let ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(_)) = self.chunk { + } else { + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(super::bigtable_data::Family::new())); + } + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_contents(&mut self) -> super::bigtable_data::Family { + if self.has_row_contents() { + match self.chunk.take() { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(v)) => v, + _ => panic!(), + } + } else { + super::bigtable_data::Family::new() + } + } + + // bool reset_row = 2; + + + pub fn get_reset_row(&self) -> bool { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::reset_row(v)) => v, + _ => false, + } + } + pub fn clear_reset_row(&mut self) { + self.chunk = ::std::option::Option::None; + } + + pub fn has_reset_row(&self) -> bool { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::reset_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_reset_row(&mut self, v: bool) { + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::reset_row(v)) + } + + // bool commit_row = 3; + + + pub fn get_commit_row(&self) -> bool { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::commit_row(v)) => v, + _ => false, + } + } + pub fn clear_commit_row(&mut self) { + self.chunk = ::std::option::Option::None; + } + + pub fn has_commit_row(&self) -> bool { + match self.chunk { + ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::commit_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_commit_row(&mut self, v: bool) { + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::commit_row(v)) + } +} + +impl ::protobuf::Message for ReadRowsResponse_Chunk { + fn is_initialized(&self) -> bool { + if let Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(ref v)) = self.chunk { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::row_contents(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::reset_row(is.read_bool()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.chunk = ::std::option::Option::Some(ReadRowsResponse_Chunk_oneof_chunk::commit_row(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.chunk { + match v { + &ReadRowsResponse_Chunk_oneof_chunk::row_contents(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &ReadRowsResponse_Chunk_oneof_chunk::reset_row(v) => { + my_size += 2; + }, + &ReadRowsResponse_Chunk_oneof_chunk::commit_row(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.chunk { + match v { + &ReadRowsResponse_Chunk_oneof_chunk::row_contents(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &ReadRowsResponse_Chunk_oneof_chunk::reset_row(v) => { + os.write_bool(2, v)?; + }, + &ReadRowsResponse_Chunk_oneof_chunk::commit_row(v) => { + os.write_bool(3, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsResponse_Chunk { + ReadRowsResponse_Chunk::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::bigtable_data::Family>( + "row_contents", + ReadRowsResponse_Chunk::has_row_contents, + ReadRowsResponse_Chunk::get_row_contents, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "reset_row", + ReadRowsResponse_Chunk::has_reset_row, + ReadRowsResponse_Chunk::get_reset_row, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "commit_row", + ReadRowsResponse_Chunk::has_commit_row, + ReadRowsResponse_Chunk::get_commit_row, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsResponse_Chunk", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsResponse_Chunk { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsResponse_Chunk, + }; + unsafe { + instance.get(ReadRowsResponse_Chunk::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsResponse_Chunk { + fn clear(&mut self) { + self.chunk = ::std::option::Option::None; + self.chunk = ::std::option::Option::None; + self.chunk = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsResponse_Chunk { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse_Chunk { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SampleRowKeysRequest { + // message fields + pub table_name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SampleRowKeysRequest { + fn default() -> &'a SampleRowKeysRequest { + ::default_instance() + } +} + +impl SampleRowKeysRequest { + pub fn new() -> SampleRowKeysRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for SampleRowKeysRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SampleRowKeysRequest { + SampleRowKeysRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &SampleRowKeysRequest| { &m.table_name }, + |m: &mut SampleRowKeysRequest| { &mut m.table_name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SampleRowKeysRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SampleRowKeysRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SampleRowKeysRequest, + }; + unsafe { + instance.get(SampleRowKeysRequest::new) + } + } +} + +impl ::protobuf::Clear for SampleRowKeysRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SampleRowKeysRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SampleRowKeysRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SampleRowKeysResponse { + // message fields + pub row_key: ::std::vec::Vec, + pub offset_bytes: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SampleRowKeysResponse { + fn default() -> &'a SampleRowKeysResponse { + ::default_instance() + } +} + +impl SampleRowKeysResponse { + pub fn new() -> SampleRowKeysResponse { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // int64 offset_bytes = 2; + + + pub fn get_offset_bytes(&self) -> i64 { + self.offset_bytes + } + pub fn clear_offset_bytes(&mut self) { + self.offset_bytes = 0; + } + + // Param is passed by value, moved + pub fn set_offset_bytes(&mut self, v: i64) { + self.offset_bytes = v; + } +} + +impl ::protobuf::Message for SampleRowKeysResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.offset_bytes = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + if self.offset_bytes != 0 { + my_size += ::protobuf::rt::value_size(2, self.offset_bytes, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + if self.offset_bytes != 0 { + os.write_int64(2, self.offset_bytes)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SampleRowKeysResponse { + SampleRowKeysResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &SampleRowKeysResponse| { &m.row_key }, + |m: &mut SampleRowKeysResponse| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "offset_bytes", + |m: &SampleRowKeysResponse| { &m.offset_bytes }, + |m: &mut SampleRowKeysResponse| { &mut m.offset_bytes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SampleRowKeysResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SampleRowKeysResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SampleRowKeysResponse, + }; + unsafe { + instance.get(SampleRowKeysResponse::new) + } + } +} + +impl ::protobuf::Clear for SampleRowKeysResponse { + fn clear(&mut self) { + self.row_key.clear(); + self.offset_bytes = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SampleRowKeysResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SampleRowKeysResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowRequest { + // message fields + pub table_name: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowRequest { + fn default() -> &'a MutateRowRequest { + ::default_instance() + } +} + +impl MutateRowRequest { + pub fn new() -> MutateRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.Mutation mutations = 3; + + + pub fn get_mutations(&self) -> &[super::bigtable_data::Mutation] { + &self.mutations + } + pub fn clear_mutations(&mut self) { + self.mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.mutations + } + + // Take field + pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + for value in &self.mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + for v in &self.mutations { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowRequest { + MutateRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &MutateRowRequest| { &m.table_name }, + |m: &mut MutateRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &MutateRowRequest| { &m.row_key }, + |m: &mut MutateRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "mutations", + |m: &MutateRowRequest| { &m.mutations }, + |m: &mut MutateRowRequest| { &mut m.mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowRequest, + }; + unsafe { + instance.get(MutateRowRequest::new) + } + } +} + +impl ::protobuf::Clear for MutateRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.row_key.clear(); + self.mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsRequest { + // message fields + pub table_name: ::std::string::String, + pub entries: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsRequest { + fn default() -> &'a MutateRowsRequest { + ::default_instance() + } +} + +impl MutateRowsRequest { + pub fn new() -> MutateRowsRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // repeated .google.bigtable.v1.MutateRowsRequest.Entry entries = 2; + + + pub fn get_entries(&self) -> &[MutateRowsRequest_Entry] { + &self.entries + } + pub fn clear_entries(&mut self) { + self.entries.clear(); + } + + // Param is passed by value, moved + pub fn set_entries(&mut self, v: ::protobuf::RepeatedField) { + self.entries = v; + } + + // Mutable pointer to the field. + pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.entries + } + + // Take field + pub fn take_entries(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsRequest { + fn is_initialized(&self) -> bool { + for v in &self.entries { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + for value in &self.entries { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + for v in &self.entries { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsRequest { + MutateRowsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &MutateRowsRequest| { &m.table_name }, + |m: &mut MutateRowsRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "entries", + |m: &MutateRowsRequest| { &m.entries }, + |m: &mut MutateRowsRequest| { &mut m.entries }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsRequest, + }; + unsafe { + instance.get(MutateRowsRequest::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.entries.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsRequest_Entry { + // message fields + pub row_key: ::std::vec::Vec, + pub mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsRequest_Entry { + fn default() -> &'a MutateRowsRequest_Entry { + ::default_instance() + } +} + +impl MutateRowsRequest_Entry { + pub fn new() -> MutateRowsRequest_Entry { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.Mutation mutations = 2; + + + pub fn get_mutations(&self) -> &[super::bigtable_data::Mutation] { + &self.mutations + } + pub fn clear_mutations(&mut self) { + self.mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.mutations + } + + // Take field + pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsRequest_Entry { + fn is_initialized(&self) -> bool { + for v in &self.mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + for value in &self.mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + for v in &self.mutations { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsRequest_Entry { + MutateRowsRequest_Entry::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &MutateRowsRequest_Entry| { &m.row_key }, + |m: &mut MutateRowsRequest_Entry| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "mutations", + |m: &MutateRowsRequest_Entry| { &m.mutations }, + |m: &mut MutateRowsRequest_Entry| { &mut m.mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsRequest_Entry", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsRequest_Entry { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsRequest_Entry, + }; + unsafe { + instance.get(MutateRowsRequest_Entry::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsRequest_Entry { + fn clear(&mut self) { + self.row_key.clear(); + self.mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsRequest_Entry { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest_Entry { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsResponse { + // message fields + pub statuses: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsResponse { + fn default() -> &'a MutateRowsResponse { + ::default_instance() + } +} + +impl MutateRowsResponse { + pub fn new() -> MutateRowsResponse { + ::std::default::Default::default() + } + + // repeated .google.rpc.Status statuses = 1; + + + pub fn get_statuses(&self) -> &[super::status::Status] { + &self.statuses + } + pub fn clear_statuses(&mut self) { + self.statuses.clear(); + } + + // Param is passed by value, moved + pub fn set_statuses(&mut self, v: ::protobuf::RepeatedField) { + self.statuses = v; + } + + // Mutable pointer to the field. + pub fn mut_statuses(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.statuses + } + + // Take field + pub fn take_statuses(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.statuses, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsResponse { + fn is_initialized(&self) -> bool { + for v in &self.statuses { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.statuses)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.statuses { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.statuses { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsResponse { + MutateRowsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "statuses", + |m: &MutateRowsResponse| { &m.statuses }, + |m: &mut MutateRowsResponse| { &mut m.statuses }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsResponse, + }; + unsafe { + instance.get(MutateRowsResponse::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsResponse { + fn clear(&mut self) { + self.statuses.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckAndMutateRowRequest { + // message fields + pub table_name: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub predicate_filter: ::protobuf::SingularPtrField, + pub true_mutations: ::protobuf::RepeatedField, + pub false_mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckAndMutateRowRequest { + fn default() -> &'a CheckAndMutateRowRequest { + ::default_instance() + } +} + +impl CheckAndMutateRowRequest { + pub fn new() -> CheckAndMutateRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // .google.bigtable.v1.RowFilter predicate_filter = 6; + + + pub fn get_predicate_filter(&self) -> &super::bigtable_data::RowFilter { + self.predicate_filter.as_ref().unwrap_or_else(|| super::bigtable_data::RowFilter::default_instance()) + } + pub fn clear_predicate_filter(&mut self) { + self.predicate_filter.clear(); + } + + pub fn has_predicate_filter(&self) -> bool { + self.predicate_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_predicate_filter(&mut self, v: super::bigtable_data::RowFilter) { + self.predicate_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_predicate_filter(&mut self) -> &mut super::bigtable_data::RowFilter { + if self.predicate_filter.is_none() { + self.predicate_filter.set_default(); + } + self.predicate_filter.as_mut().unwrap() + } + + // Take field + pub fn take_predicate_filter(&mut self) -> super::bigtable_data::RowFilter { + self.predicate_filter.take().unwrap_or_else(|| super::bigtable_data::RowFilter::new()) + } + + // repeated .google.bigtable.v1.Mutation true_mutations = 4; + + + pub fn get_true_mutations(&self) -> &[super::bigtable_data::Mutation] { + &self.true_mutations + } + pub fn clear_true_mutations(&mut self) { + self.true_mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_true_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.true_mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_true_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.true_mutations + } + + // Take field + pub fn take_true_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.true_mutations, ::protobuf::RepeatedField::new()) + } + + // repeated .google.bigtable.v1.Mutation false_mutations = 5; + + + pub fn get_false_mutations(&self) -> &[super::bigtable_data::Mutation] { + &self.false_mutations + } + pub fn clear_false_mutations(&mut self) { + self.false_mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_false_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.false_mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_false_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.false_mutations + } + + // Take field + pub fn take_false_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.false_mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CheckAndMutateRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.predicate_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.true_mutations { + if !v.is_initialized() { + return false; + } + }; + for v in &self.false_mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.predicate_filter)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.true_mutations)?; + }, + 5 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.false_mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + if let Some(ref v) = self.predicate_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.true_mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.false_mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + if let Some(ref v) = self.predicate_filter.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.true_mutations { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.false_mutations { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckAndMutateRowRequest { + CheckAndMutateRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &CheckAndMutateRowRequest| { &m.table_name }, + |m: &mut CheckAndMutateRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &CheckAndMutateRowRequest| { &m.row_key }, + |m: &mut CheckAndMutateRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "predicate_filter", + |m: &CheckAndMutateRowRequest| { &m.predicate_filter }, + |m: &mut CheckAndMutateRowRequest| { &mut m.predicate_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "true_mutations", + |m: &CheckAndMutateRowRequest| { &m.true_mutations }, + |m: &mut CheckAndMutateRowRequest| { &mut m.true_mutations }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "false_mutations", + |m: &CheckAndMutateRowRequest| { &m.false_mutations }, + |m: &mut CheckAndMutateRowRequest| { &mut m.false_mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckAndMutateRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckAndMutateRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckAndMutateRowRequest, + }; + unsafe { + instance.get(CheckAndMutateRowRequest::new) + } + } +} + +impl ::protobuf::Clear for CheckAndMutateRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.row_key.clear(); + self.predicate_filter.clear(); + self.true_mutations.clear(); + self.false_mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckAndMutateRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckAndMutateRowResponse { + // message fields + pub predicate_matched: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckAndMutateRowResponse { + fn default() -> &'a CheckAndMutateRowResponse { + ::default_instance() + } +} + +impl CheckAndMutateRowResponse { + pub fn new() -> CheckAndMutateRowResponse { + ::std::default::Default::default() + } + + // bool predicate_matched = 1; + + + pub fn get_predicate_matched(&self) -> bool { + self.predicate_matched + } + pub fn clear_predicate_matched(&mut self) { + self.predicate_matched = false; + } + + // Param is passed by value, moved + pub fn set_predicate_matched(&mut self, v: bool) { + self.predicate_matched = v; + } +} + +impl ::protobuf::Message for CheckAndMutateRowResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.predicate_matched = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.predicate_matched != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.predicate_matched != false { + os.write_bool(1, self.predicate_matched)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckAndMutateRowResponse { + CheckAndMutateRowResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "predicate_matched", + |m: &CheckAndMutateRowResponse| { &m.predicate_matched }, + |m: &mut CheckAndMutateRowResponse| { &mut m.predicate_matched }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckAndMutateRowResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckAndMutateRowResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckAndMutateRowResponse, + }; + unsafe { + instance.get(CheckAndMutateRowResponse::new) + } + } +} + +impl ::protobuf::Clear for CheckAndMutateRowResponse { + fn clear(&mut self) { + self.predicate_matched = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckAndMutateRowResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadModifyWriteRowRequest { + // message fields + pub table_name: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadModifyWriteRowRequest { + fn default() -> &'a ReadModifyWriteRowRequest { + ::default_instance() + } +} + +impl ReadModifyWriteRowRequest { + pub fn new() -> ReadModifyWriteRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v1.ReadModifyWriteRule rules = 3; + + + pub fn get_rules(&self) -> &[super::bigtable_data::ReadModifyWriteRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ReadModifyWriteRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + for v in &self.rules { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadModifyWriteRowRequest { + ReadModifyWriteRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &ReadModifyWriteRowRequest| { &m.table_name }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &ReadModifyWriteRowRequest| { &m.row_key }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &ReadModifyWriteRowRequest| { &m.rules }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadModifyWriteRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadModifyWriteRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadModifyWriteRowRequest, + }; + unsafe { + instance.get(ReadModifyWriteRowRequest::new) + } + } +} + +impl ::protobuf::Clear for ReadModifyWriteRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.row_key.clear(); + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadModifyWriteRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n2google/bigtable/v1/bigtable_service_messages.proto\x12\x12google.bigt\ + able.v1\x1a&google/bigtable/v1/bigtable_data.proto\x1a\x17google/rpc/sta\ + tus.proto\"\xdc\x02\n\x0fReadRowsRequest\x12\x1d\n\ntable_name\x18\x01\ + \x20\x01(\tR\ttableName\x12\x19\n\x07row_key\x18\x02\x20\x01(\x0cH\0R\ + \x06rowKey\x12;\n\trow_range\x18\x03\x20\x01(\x0b2\x1c.google.bigtable.v\ + 1.RowRangeH\0R\x08rowRange\x125\n\x07row_set\x18\x08\x20\x01(\x0b2\x1a.g\ + oogle.bigtable.v1.RowSetH\0R\x06rowSet\x125\n\x06filter\x18\x05\x20\x01(\ + \x0b2\x1d.google.bigtable.v1.RowFilterR\x06filter\x124\n\x16allow_row_in\ + terleaving\x18\x06\x20\x01(\x08R\x14allowRowInterleaving\x12$\n\x0enum_r\ + ows_limit\x18\x07\x20\x01(\x03R\x0cnumRowsLimitB\x08\n\x06target\"\x83\ + \x02\n\x10ReadRowsResponse\x12\x17\n\x07row_key\x18\x01\x20\x01(\x0cR\ + \x06rowKey\x12B\n\x06chunks\x18\x02\x20\x03(\x0b2*.google.bigtable.v1.Re\ + adRowsResponse.ChunkR\x06chunks\x1a\x91\x01\n\x05Chunk\x12?\n\x0crow_con\ + tents\x18\x01\x20\x01(\x0b2\x1a.google.bigtable.v1.FamilyH\0R\x0browCont\ + ents\x12\x1d\n\treset_row\x18\x02\x20\x01(\x08H\0R\x08resetRow\x12\x1f\n\ + \ncommit_row\x18\x03\x20\x01(\x08H\0R\tcommitRowB\x07\n\x05chunk\"5\n\ + \x14SampleRowKeysRequest\x12\x1d\n\ntable_name\x18\x01\x20\x01(\tR\ttabl\ + eName\"S\n\x15SampleRowKeysResponse\x12\x17\n\x07row_key\x18\x01\x20\x01\ + (\x0cR\x06rowKey\x12!\n\x0coffset_bytes\x18\x02\x20\x01(\x03R\x0boffsetB\ + ytes\"\x86\x01\n\x10MutateRowRequest\x12\x1d\n\ntable_name\x18\x01\x20\ + \x01(\tR\ttableName\x12\x17\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKey\ + \x12:\n\tmutations\x18\x03\x20\x03(\x0b2\x1c.google.bigtable.v1.Mutation\ + R\tmutations\"\xd7\x01\n\x11MutateRowsRequest\x12\x1d\n\ntable_name\x18\ + \x01\x20\x01(\tR\ttableName\x12E\n\x07entries\x18\x02\x20\x03(\x0b2+.goo\ + gle.bigtable.v1.MutateRowsRequest.EntryR\x07entries\x1a\\\n\x05Entry\x12\ + \x17\n\x07row_key\x18\x01\x20\x01(\x0cR\x06rowKey\x12:\n\tmutations\x18\ + \x02\x20\x03(\x0b2\x1c.google.bigtable.v1.MutationR\tmutations\"D\n\x12M\ + utateRowsResponse\x12.\n\x08statuses\x18\x01\x20\x03(\x0b2\x12.google.rp\ + c.StatusR\x08statuses\"\xa8\x02\n\x18CheckAndMutateRowRequest\x12\x1d\n\ + \ntable_name\x18\x01\x20\x01(\tR\ttableName\x12\x17\n\x07row_key\x18\x02\ + \x20\x01(\x0cR\x06rowKey\x12H\n\x10predicate_filter\x18\x06\x20\x01(\x0b\ + 2\x1d.google.bigtable.v1.RowFilterR\x0fpredicateFilter\x12C\n\x0etrue_mu\ + tations\x18\x04\x20\x03(\x0b2\x1c.google.bigtable.v1.MutationR\rtrueMuta\ + tions\x12E\n\x0ffalse_mutations\x18\x05\x20\x03(\x0b2\x1c.google.bigtabl\ + e.v1.MutationR\x0efalseMutations\"H\n\x19CheckAndMutateRowResponse\x12+\ + \n\x11predicate_matched\x18\x01\x20\x01(\x08R\x10predicateMatched\"\x92\ + \x01\n\x19ReadModifyWriteRowRequest\x12\x1d\n\ntable_name\x18\x01\x20\ + \x01(\tR\ttableName\x12\x17\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKey\ + \x12=\n\x05rules\x18\x03\x20\x03(\x0b2'.google.bigtable.v1.ReadModifyWri\ + teRuleR\x05rulesBt\n\x16com.google.bigtable.v1B\x1cBigtableServiceMessag\ + esProtoP\x01Z:google.golang.org/genproto/googleapis/bigtable/v1;bigtable\ + J\x86I\n\x07\x12\x05\x0e\0\xd9\x01\x01\n\xbd\x04\n\x01\x0c\x12\x03\x0e\0\ + \x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\n\x20Licensed\x20\ + under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"Licens\ + e\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20c\ + ompliance\x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20c\ + opy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apac\ + he.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicabl\ + e\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distri\ + buted\x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"A\ + S\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\ + \x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\ + \x20License\x20for\x20the\x20specific\x20language\x20governing\x20permis\ + sions\x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\ + \x02\x12\x03\x10\0\x1b\n\t\n\x02\x03\0\x12\x03\x12\00\n\t\n\x02\x03\x01\ + \x12\x03\x13\0!\n\x08\n\x01\x08\x12\x03\x15\0Q\n\t\n\x02\x08\x0b\x12\x03\ + \x15\0Q\n\x08\n\x01\x08\x12\x03\x16\0\"\n\t\n\x02\x08\n\x12\x03\x16\0\"\ + \n\x08\n\x01\x08\x12\x03\x17\0=\n\t\n\x02\x08\x08\x12\x03\x17\0=\n\x08\n\ + \x01\x08\x12\x03\x18\0/\n\t\n\x02\x08\x01\x12\x03\x18\0/\n:\n\x02\x04\0\ + \x12\x04\x1c\0>\x01\x1a.\x20Request\x20message\x20for\x20BigtableServer.\ + ReadRows.\n\n\n\n\x03\x04\0\x01\x12\x03\x1c\x08\x17\n?\n\x04\x04\0\x02\0\ + \x12\x03\x1e\x02\x18\x1a2\x20The\x20unique\x20name\x20of\x20the\x20table\ + \x20from\x20which\x20to\x20read.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04\x1e\ + \x02\x1c\x19\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x1e\x02\x08\n\x0c\n\x05\ + \x04\0\x02\0\x01\x12\x03\x1e\t\x13\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\ + \x1e\x16\x17\nM\n\x04\x04\0\x08\0\x12\x04!\x02,\x03\x1a?\x20If\x20neithe\ + r\x20row_key\x20nor\x20row_range\x20is\x20set,\x20reads\x20from\x20all\ + \x20rows.\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03!\x08\x0e\n:\n\x04\x04\0\ + \x02\x01\x12\x03#\x04\x16\x1a-\x20The\x20key\x20of\x20a\x20single\x20row\ + \x20from\x20which\x20to\x20read.\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\ + #\x04\t\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03#\n\x11\n\x0c\n\x05\x04\0\ + \x02\x01\x03\x12\x03#\x14\x15\n2\n\x04\x04\0\x02\x02\x12\x03&\x04\x1b\ + \x1a%\x20A\x20range\x20of\x20rows\x20from\x20which\x20to\x20read.\n\n\ + \x0c\n\x05\x04\0\x02\x02\x06\x12\x03&\x04\x0c\n\x0c\n\x05\x04\0\x02\x02\ + \x01\x12\x03&\r\x16\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03&\x19\x1a\n\xb4\ + \x01\n\x04\x04\0\x02\x03\x12\x03+\x04\x17\x1a\xa6\x01\x20A\x20set\x20of\ + \x20rows\x20from\x20which\x20to\x20read.\x20Entries\x20need\x20not\x20be\ + \x20in\x20order,\x20and\x20will\n\x20be\x20deduplicated\x20before\x20rea\ + ding.\n\x20The\x20total\x20serialized\x20size\x20of\x20the\x20set\x20mus\ + t\x20not\x20exceed\x201MB.\n\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03+\x04\ + \n\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03+\x0b\x12\n\x0c\n\x05\x04\0\x02\ + \x03\x03\x12\x03+\x15\x16\nn\n\x04\x04\0\x02\x04\x12\x030\x02\x17\x1aa\ + \x20The\x20filter\x20to\x20apply\x20to\x20the\x20contents\x20of\x20the\ + \x20specified\x20row(s).\x20If\x20unset,\n\x20reads\x20the\x20entire\x20\ + table.\n\n\r\n\x05\x04\0\x02\x04\x04\x12\x040\x02,\x03\n\x0c\n\x05\x04\0\ + \x02\x04\x06\x12\x030\x02\x0b\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x030\x0c\ + \x12\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x030\x15\x16\n\xab\x03\n\x04\x04\ + \0\x02\x05\x12\x038\x02\"\x1a\x9d\x03\x20By\x20default,\x20rows\x20are\ + \x20read\x20sequentially,\x20producing\x20results\x20which\x20are\n\x20g\ + uaranteed\x20to\x20arrive\x20in\x20increasing\x20row\x20order.\x20Settin\ + g\n\x20\"allow_row_interleaving\"\x20to\x20true\x20allows\x20multiple\ + \x20rows\x20to\x20be\x20interleaved\x20in\n\x20the\x20response\x20stream\ + ,\x20which\x20increases\x20throughput\x20but\x20breaks\x20this\x20guaran\ + tee,\n\x20and\x20may\x20force\x20the\x20client\x20to\x20use\x20more\x20m\ + emory\x20to\x20buffer\x20partially-received\n\x20rows.\x20Cannot\x20be\ + \x20set\x20to\x20true\x20when\x20specifying\x20\"num_rows_limit\".\n\n\r\ + \n\x05\x04\0\x02\x05\x04\x12\x048\x020\x17\n\x0c\n\x05\x04\0\x02\x05\x05\ + \x12\x038\x02\x06\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x038\x07\x1d\n\x0c\n\ + \x05\x04\0\x02\x05\x03\x12\x038\x20!\n\xcf\x01\n\x04\x04\0\x02\x06\x12\ + \x03=\x02\x1b\x1a\xc1\x01\x20The\x20read\x20will\x20terminate\x20after\ + \x20committing\x20to\x20N\x20rows'\x20worth\x20of\x20results.\x20The\n\ + \x20default\x20(zero)\x20is\x20to\x20return\x20all\x20results.\n\x20Note\ + \x20that\x20\"allow_row_interleaving\"\x20cannot\x20be\x20set\x20to\x20t\ + rue\x20when\x20this\x20is\x20set.\n\n\r\n\x05\x04\0\x02\x06\x04\x12\x04=\ + \x028\"\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x03=\x02\x07\n\x0c\n\x05\x04\0\ + \x02\x06\x01\x12\x03=\x08\x16\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03=\x19\ + \x1a\n<\n\x02\x04\x01\x12\x04A\0]\x01\x1a0\x20Response\x20message\x20for\ + \x20BigtableService.ReadRows.\n\n\n\n\x03\x04\x01\x01\x12\x03A\x08\x18\n\ + d\n\x04\x04\x01\x03\0\x12\x04D\x02T\x03\x1aV\x20Specifies\x20a\x20piece\ + \x20of\x20a\x20row's\x20contents\x20returned\x20as\x20part\x20of\x20the\ + \x20read\n\x20response\x20stream.\n\n\x0c\n\x05\x04\x01\x03\0\x01\x12\ + \x03D\n\x0f\n\x0e\n\x06\x04\x01\x03\0\x08\0\x12\x04E\x04S\x05\n\x0e\n\ + \x07\x04\x01\x03\0\x08\0\x01\x12\x03E\n\x0f\n\x8b\x02\n\x06\x04\x01\x03\ + \0\x02\0\x12\x03J\x06\x1e\x1a\xfb\x01\x20A\x20subset\x20of\x20the\x20dat\ + a\x20from\x20a\x20particular\x20row.\x20As\x20long\x20as\x20no\x20\"rese\ + t_row\"\n\x20is\x20received\x20in\x20between,\x20multiple\x20\"row_conte\ + nts\"\x20from\x20the\x20same\x20row\x20are\n\x20from\x20the\x20same\x20a\ + tomic\x20view\x20of\x20that\x20row,\x20and\x20will\x20be\x20received\x20\ + in\x20the\n\x20expected\x20family/column/timestamp\x20order.\n\n\x0e\n\ + \x07\x04\x01\x03\0\x02\0\x06\x12\x03J\x06\x0c\n\x0e\n\x07\x04\x01\x03\0\ + \x02\0\x01\x12\x03J\r\x19\n\x0e\n\x07\x04\x01\x03\0\x02\0\x03\x12\x03J\ + \x1c\x1d\n\x84\x01\n\x06\x04\x01\x03\0\x02\x01\x12\x03N\x06\x19\x1au\x20\ + Indicates\x20that\x20the\x20client\x20should\x20drop\x20all\x20previous\ + \x20chunks\x20for\n\x20\"row_key\",\x20as\x20it\x20will\x20be\x20re-read\ + \x20from\x20the\x20beginning.\n\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x05\ + \x12\x03N\x06\n\n\x0e\n\x07\x04\x01\x03\0\x02\x01\x01\x12\x03N\x0b\x14\n\ + \x0e\n\x07\x04\x01\x03\0\x02\x01\x03\x12\x03N\x17\x18\n\x82\x01\n\x06\ + \x04\x01\x03\0\x02\x02\x12\x03R\x06\x1a\x1as\x20Indicates\x20that\x20the\ + \x20client\x20can\x20safely\x20process\x20all\x20previous\x20chunks\x20f\ + or\n\x20\"row_key\",\x20as\x20its\x20data\x20has\x20been\x20fully\x20rea\ + d.\n\n\x0e\n\x07\x04\x01\x03\0\x02\x02\x05\x12\x03R\x06\n\n\x0e\n\x07\ + \x04\x01\x03\0\x02\x02\x01\x12\x03R\x0b\x15\n\x0e\n\x07\x04\x01\x03\0\ + \x02\x02\x03\x12\x03R\x18\x19\n\xb8\x01\n\x04\x04\x01\x02\0\x12\x03Y\x02\ + \x14\x1a\xaa\x01\x20The\x20key\x20of\x20the\x20row\x20for\x20which\x20we\ + 're\x20receiving\x20data.\n\x20Results\x20will\x20be\x20received\x20in\ + \x20increasing\x20row\x20key\x20order,\x20unless\n\x20\"allow_row_interl\ + eaving\"\x20was\x20specified\x20in\x20the\x20request.\n\n\r\n\x05\x04\ + \x01\x02\0\x04\x12\x04Y\x02T\x03\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03Y\ + \x02\x07\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03Y\x08\x0f\n\x0c\n\x05\x04\ + \x01\x02\0\x03\x12\x03Y\x12\x13\nD\n\x04\x04\x01\x02\x01\x12\x03\\\x02\ + \x1c\x1a7\x20One\x20or\x20more\x20chunks\x20of\x20the\x20row\x20specifie\ + d\x20by\x20\"row_key\".\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03\\\x02\ + \n\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03\\\x0b\x10\n\x0c\n\x05\x04\x01\ + \x02\x01\x01\x12\x03\\\x11\x17\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\\\ + \x1a\x1b\n@\n\x02\x04\x02\x12\x04`\0c\x01\x1a4\x20Request\x20message\x20\ + for\x20BigtableService.SampleRowKeys.\n\n\n\n\x03\x04\x02\x01\x12\x03`\ + \x08\x1c\nJ\n\x04\x04\x02\x02\0\x12\x03b\x02\x18\x1a=\x20The\x20unique\ + \x20name\x20of\x20the\x20table\x20from\x20which\x20to\x20sample\x20row\ + \x20keys.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04b\x02`\x1e\n\x0c\n\x05\ + \x04\x02\x02\0\x05\x12\x03b\x02\x08\n\x0c\n\x05\x04\x02\x02\0\x01\x12\ + \x03b\t\x13\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03b\x16\x17\nA\n\x02\x04\ + \x03\x12\x04f\0u\x01\x1a5\x20Response\x20message\x20for\x20BigtableServi\ + ce.SampleRowKeys.\n\n\n\n\x03\x04\x03\x01\x12\x03f\x08\x1d\n\xdf\x03\n\ + \x04\x04\x03\x02\0\x12\x03n\x02\x14\x1a\xd1\x03\x20Sorted\x20streamed\ + \x20sequence\x20of\x20sample\x20row\x20keys\x20in\x20the\x20table.\x20Th\ + e\x20table\x20might\n\x20have\x20contents\x20before\x20the\x20first\x20r\ + ow\x20key\x20in\x20the\x20list\x20and\x20after\x20the\x20last\x20one,\n\ + \x20but\x20a\x20key\x20containing\x20the\x20empty\x20string\x20indicates\ + \x20\"end\x20of\x20table\"\x20and\x20will\x20be\n\x20the\x20last\x20resp\ + onse\x20given,\x20if\x20present.\n\x20Note\x20that\x20row\x20keys\x20in\ + \x20this\x20list\x20may\x20not\x20have\x20ever\x20been\x20written\x20to\ + \x20or\x20read\n\x20from,\x20and\x20users\x20should\x20therefore\x20not\ + \x20make\x20any\x20assumptions\x20about\x20the\x20row\x20key\n\x20struct\ + ure\x20that\x20are\x20specific\x20to\x20their\x20use\x20case.\n\n\r\n\ + \x05\x04\x03\x02\0\x04\x12\x04n\x02f\x1f\n\x0c\n\x05\x04\x03\x02\0\x05\ + \x12\x03n\x02\x07\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03n\x08\x0f\n\x0c\n\ + \x05\x04\x03\x02\0\x03\x12\x03n\x12\x13\n\xff\x01\n\x04\x04\x03\x02\x01\ + \x12\x03t\x02\x19\x1a\xf1\x01\x20Approximate\x20total\x20storage\x20spac\ + e\x20used\x20by\x20all\x20rows\x20in\x20the\x20table\x20which\x20precede\ + \n\x20\"row_key\".\x20Buffering\x20the\x20contents\x20of\x20all\x20rows\ + \x20between\x20two\x20subsequent\n\x20samples\x20would\x20require\x20spa\ + ce\x20roughly\x20equal\x20to\x20the\x20difference\x20in\x20their\n\x20\"\ + offset_bytes\"\x20fields.\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04t\x02n\ + \x14\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03t\x02\x07\n\x0c\n\x05\x04\ + \x03\x02\x01\x01\x12\x03t\x08\x14\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\ + \x03t\x17\x18\n=\n\x02\x04\x04\x12\x05x\0\x83\x01\x01\x1a0\x20Request\ + \x20message\x20for\x20BigtableService.MutateRow.\n\n\n\n\x03\x04\x04\x01\ + \x12\x03x\x08\x18\nT\n\x04\x04\x04\x02\0\x12\x03z\x02\x18\x1aG\x20The\ + \x20unique\x20name\x20of\x20the\x20table\x20to\x20which\x20the\x20mutati\ + on\x20should\x20be\x20applied.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04z\ + \x02x\x1a\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03z\x02\x08\n\x0c\n\x05\x04\ + \x04\x02\0\x01\x12\x03z\t\x13\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03z\x16\ + \x17\nJ\n\x04\x04\x04\x02\x01\x12\x03}\x02\x14\x1a=\x20The\x20key\x20of\ + \x20the\x20row\x20to\x20which\x20the\x20mutation\x20should\x20be\x20appl\ + ied.\n\n\r\n\x05\x04\x04\x02\x01\x04\x12\x04}\x02z\x18\n\x0c\n\x05\x04\ + \x04\x02\x01\x05\x12\x03}\x02\x07\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\ + \x03}\x08\x0f\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03}\x12\x13\n\xd7\x01\ + \n\x04\x04\x04\x02\x02\x12\x04\x82\x01\x02\"\x1a\xc8\x01\x20Changes\x20t\ + o\x20be\x20atomically\x20applied\x20to\x20the\x20specified\x20row.\x20En\ + tries\x20are\x20applied\n\x20in\x20order,\x20meaning\x20that\x20earlier\ + \x20mutations\x20can\x20be\x20masked\x20by\x20later\x20ones.\n\x20Must\ + \x20contain\x20at\x20least\x20one\x20entry\x20and\x20at\x20most\x2010000\ + 0.\n\n\r\n\x05\x04\x04\x02\x02\x04\x12\x04\x82\x01\x02\n\n\r\n\x05\x04\ + \x04\x02\x02\x06\x12\x04\x82\x01\x0b\x13\n\r\n\x05\x04\x04\x02\x02\x01\ + \x12\x04\x82\x01\x14\x1d\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\x82\x01\ + \x20!\n?\n\x02\x04\x05\x12\x06\x86\x01\0\x9b\x01\x01\x1a1\x20Request\x20\ + message\x20for\x20BigtableService.MutateRows.\n\n\x0b\n\x03\x04\x05\x01\ + \x12\x04\x86\x01\x08\x19\n\x0e\n\x04\x04\x05\x03\0\x12\x06\x87\x01\x02\ + \x90\x01\x03\n\r\n\x05\x04\x05\x03\0\x01\x12\x04\x87\x01\n\x0f\nP\n\x06\ + \x04\x05\x03\0\x02\0\x12\x04\x89\x01\x04\x16\x1a@\x20The\x20key\x20of\ + \x20the\x20row\x20to\x20which\x20the\x20`mutations`\x20should\x20be\x20a\ + pplied.\n\n\x11\n\x07\x04\x05\x03\0\x02\0\x04\x12\x06\x89\x01\x04\x87\ + \x01\x11\n\x0f\n\x07\x04\x05\x03\0\x02\0\x05\x12\x04\x89\x01\x04\t\n\x0f\ + \n\x07\x04\x05\x03\0\x02\0\x01\x12\x04\x89\x01\n\x11\n\x0f\n\x07\x04\x05\ + \x03\0\x02\0\x03\x12\x04\x89\x01\x14\x15\n\xd1\x01\n\x06\x04\x05\x03\0\ + \x02\x01\x12\x04\x8f\x01\x04$\x1a\xc0\x01\x20Changes\x20to\x20be\x20atom\ + ically\x20applied\x20to\x20the\x20specified\x20row.\x20Mutations\x20are\ + \n\x20applied\x20in\x20order,\x20meaning\x20that\x20earlier\x20mutations\ + \x20can\x20be\x20masked\x20by\n\x20later\x20ones.\n\x20At\x20least\x20on\ + e\x20mutation\x20must\x20be\x20specified.\n\n\x0f\n\x07\x04\x05\x03\0\ + \x02\x01\x04\x12\x04\x8f\x01\x04\x0c\n\x0f\n\x07\x04\x05\x03\0\x02\x01\ + \x06\x12\x04\x8f\x01\r\x15\n\x0f\n\x07\x04\x05\x03\0\x02\x01\x01\x12\x04\ + \x8f\x01\x16\x1f\n\x0f\n\x07\x04\x05\x03\0\x02\x01\x03\x12\x04\x8f\x01\"\ + #\nV\n\x04\x04\x05\x02\0\x12\x04\x93\x01\x02\x18\x1aH\x20The\x20unique\ + \x20name\x20of\x20the\x20table\x20to\x20which\x20the\x20mutations\x20sho\ + uld\x20be\x20applied.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\x93\x01\ + \x02\x90\x01\x03\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x93\x01\x02\x08\n\r\ + \n\x05\x04\x05\x02\0\x01\x12\x04\x93\x01\t\x13\n\r\n\x05\x04\x05\x02\0\ + \x03\x12\x04\x93\x01\x16\x17\n\xaf\x02\n\x04\x04\x05\x02\x01\x12\x04\x9a\ + \x01\x02\x1d\x1a\xa0\x02\x20The\x20row\x20keys/mutations\x20to\x20be\x20\ + applied\x20in\x20bulk.\n\x20Each\x20entry\x20is\x20applied\x20as\x20an\ + \x20atomic\x20mutation,\x20but\x20the\x20entries\x20may\x20be\n\x20appli\ + ed\x20in\x20arbitrary\x20order\x20(even\x20between\x20entries\x20for\x20\ + the\x20same\x20row).\n\x20At\x20least\x20one\x20entry\x20must\x20be\x20s\ + pecified,\x20and\x20in\x20total\x20the\x20entries\x20may\n\x20contain\ + \x20at\x20most\x20100000\x20mutations.\n\n\r\n\x05\x04\x05\x02\x01\x04\ + \x12\x04\x9a\x01\x02\n\n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\x9a\x01\x0b\ + \x10\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\x9a\x01\x11\x18\n\r\n\x05\x04\ + \x05\x02\x01\x03\x12\x04\x9a\x01\x1b\x1c\n@\n\x02\x04\x06\x12\x06\x9e\ + \x01\0\xa5\x01\x01\x1a2\x20Response\x20message\x20for\x20BigtableService\ + .MutateRows.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\x9e\x01\x08\x1a\n\xd6\x02\ + \n\x04\x04\x06\x02\0\x12\x04\xa4\x01\x02*\x1a\xc7\x02\x20The\x20results\ + \x20for\x20each\x20Entry\x20from\x20the\x20request,\x20presented\x20in\ + \x20the\x20order\n\x20in\x20which\x20the\x20entries\x20were\x20originall\ + y\x20given.\n\x20Depending\x20on\x20how\x20requests\x20are\x20batched\ + \x20during\x20execution,\x20it\x20is\x20possible\n\x20for\x20one\x20Entr\ + y\x20to\x20fail\x20due\x20to\x20an\x20error\x20with\x20another\x20Entry.\ + \x20In\x20the\x20event\n\x20that\x20this\x20occurs,\x20the\x20same\x20er\ + ror\x20will\x20be\x20reported\x20for\x20both\x20entries.\n\n\r\n\x05\x04\ + \x06\x02\0\x04\x12\x04\xa4\x01\x02\n\n\r\n\x05\x04\x06\x02\0\x06\x12\x04\ + \xa4\x01\x0b\x1c\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xa4\x01\x1d%\n\r\n\ + \x05\x04\x06\x02\0\x03\x12\x04\xa4\x01()\nL\n\x02\x04\x07\x12\x06\xa8\ + \x01\0\xc3\x01\x01\x1a>\x20Request\x20message\x20for\x20BigtableService.\ + CheckAndMutateRowRequest\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xa8\x01\x08\ + \x20\nb\n\x04\x04\x07\x02\0\x12\x04\xab\x01\x02\x18\x1aT\x20The\x20uniqu\ + e\x20name\x20of\x20the\x20table\x20to\x20which\x20the\x20conditional\x20\ + mutation\x20should\x20be\n\x20applied.\n\n\x0f\n\x05\x04\x07\x02\0\x04\ + \x12\x06\xab\x01\x02\xa8\x01\"\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xab\ + \x01\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xab\x01\t\x13\n\r\n\x05\ + \x04\x07\x02\0\x03\x12\x04\xab\x01\x16\x17\nW\n\x04\x04\x07\x02\x01\x12\ + \x04\xae\x01\x02\x14\x1aI\x20The\x20key\x20of\x20the\x20row\x20to\x20whi\ + ch\x20the\x20conditional\x20mutation\x20should\x20be\x20applied.\n\n\x0f\ + \n\x05\x04\x07\x02\x01\x04\x12\x06\xae\x01\x02\xab\x01\x18\n\r\n\x05\x04\ + \x07\x02\x01\x05\x12\x04\xae\x01\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\ + \x12\x04\xae\x01\x08\x0f\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\xae\x01\ + \x12\x13\n\x80\x02\n\x04\x04\x07\x02\x02\x12\x04\xb4\x01\x02!\x1a\xf1\ + \x01\x20The\x20filter\x20to\x20be\x20applied\x20to\x20the\x20contents\ + \x20of\x20the\x20specified\x20row.\x20Depending\n\x20on\x20whether\x20or\ + \x20not\x20any\x20results\x20are\x20yielded,\x20either\x20\"true_mutatio\ + ns\"\x20or\n\x20\"false_mutations\"\x20will\x20be\x20executed.\x20If\x20\ + unset,\x20checks\x20that\x20the\x20row\x20contains\n\x20any\x20values\ + \x20at\x20all.\n\n\x0f\n\x05\x04\x07\x02\x02\x04\x12\x06\xb4\x01\x02\xae\ + \x01\x14\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\xb4\x01\x02\x0b\n\r\n\x05\ + \x04\x07\x02\x02\x01\x12\x04\xb4\x01\x0c\x1c\n\r\n\x05\x04\x07\x02\x02\ + \x03\x12\x04\xb4\x01\x1f\x20\n\xc1\x02\n\x04\x04\x07\x02\x03\x12\x04\xbb\ + \x01\x02'\x1a\xb2\x02\x20Changes\x20to\x20be\x20atomically\x20applied\ + \x20to\x20the\x20specified\x20row\x20if\x20\"predicate_filter\"\n\x20yie\ + lds\x20at\x20least\x20one\x20cell\x20when\x20applied\x20to\x20\"row_key\ + \".\x20Entries\x20are\x20applied\x20in\n\x20order,\x20meaning\x20that\ + \x20earlier\x20mutations\x20can\x20be\x20masked\x20by\x20later\x20ones.\ + \n\x20Must\x20contain\x20at\x20least\x20one\x20entry\x20if\x20\"false_mu\ + tations\"\x20is\x20empty,\x20and\x20at\x20most\n\x20100000.\n\n\r\n\x05\ + \x04\x07\x02\x03\x04\x12\x04\xbb\x01\x02\n\n\r\n\x05\x04\x07\x02\x03\x06\ + \x12\x04\xbb\x01\x0b\x13\n\r\n\x05\x04\x07\x02\x03\x01\x12\x04\xbb\x01\ + \x14\"\n\r\n\x05\x04\x07\x02\x03\x03\x12\x04\xbb\x01%&\n\xc0\x02\n\x04\ + \x04\x07\x02\x04\x12\x04\xc2\x01\x02(\x1a\xb1\x02\x20Changes\x20to\x20be\ + \x20atomically\x20applied\x20to\x20the\x20specified\x20row\x20if\x20\"pr\ + edicate_filter\"\n\x20does\x20not\x20yield\x20any\x20cells\x20when\x20ap\ + plied\x20to\x20\"row_key\".\x20Entries\x20are\x20applied\x20in\n\x20orde\ + r,\x20meaning\x20that\x20earlier\x20mutations\x20can\x20be\x20masked\x20\ + by\x20later\x20ones.\n\x20Must\x20contain\x20at\x20least\x20one\x20entry\ + \x20if\x20\"true_mutations\"\x20is\x20empty,\x20and\x20at\x20most\n\x201\ + 00000.\n\n\r\n\x05\x04\x07\x02\x04\x04\x12\x04\xc2\x01\x02\n\n\r\n\x05\ + \x04\x07\x02\x04\x06\x12\x04\xc2\x01\x0b\x13\n\r\n\x05\x04\x07\x02\x04\ + \x01\x12\x04\xc2\x01\x14#\n\r\n\x05\x04\x07\x02\x04\x03\x12\x04\xc2\x01&\ + '\nN\n\x02\x04\x08\x12\x06\xc6\x01\0\xca\x01\x01\x1a@\x20Response\x20mes\ + sage\x20for\x20BigtableService.CheckAndMutateRowRequest.\n\n\x0b\n\x03\ + \x04\x08\x01\x12\x04\xc6\x01\x08!\nk\n\x04\x04\x08\x02\0\x12\x04\xc9\x01\ + \x02\x1d\x1a]\x20Whether\x20or\x20not\x20the\x20request's\x20\"predicate\ + _filter\"\x20yielded\x20any\x20results\x20for\n\x20the\x20specified\x20r\ + ow.\n\n\x0f\n\x05\x04\x08\x02\0\x04\x12\x06\xc9\x01\x02\xc6\x01#\n\r\n\ + \x05\x04\x08\x02\0\x05\x12\x04\xc9\x01\x02\x06\n\r\n\x05\x04\x08\x02\0\ + \x01\x12\x04\xc9\x01\x07\x18\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xc9\x01\ + \x1b\x1c\nN\n\x02\x04\t\x12\x06\xcd\x01\0\xd9\x01\x01\x1a@\x20Request\ + \x20message\x20for\x20BigtableService.ReadModifyWriteRowRequest.\n\n\x0b\ + \n\x03\x04\t\x01\x12\x04\xcd\x01\x08!\ne\n\x04\x04\t\x02\0\x12\x04\xd0\ + \x01\x02\x18\x1aW\x20The\x20unique\x20name\x20of\x20the\x20table\x20to\ + \x20which\x20the\x20read/modify/write\x20rules\x20should\x20be\n\x20appl\ + ied.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\x06\xd0\x01\x02\xcd\x01#\n\r\n\ + \x05\x04\t\x02\0\x05\x12\x04\xd0\x01\x02\x08\n\r\n\x05\x04\t\x02\0\x01\ + \x12\x04\xd0\x01\t\x13\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xd0\x01\x16\x17\ + \nZ\n\x04\x04\t\x02\x01\x12\x04\xd3\x01\x02\x14\x1aL\x20The\x20key\x20of\ + \x20the\x20row\x20to\x20which\x20the\x20read/modify/write\x20rules\x20sh\ + ould\x20be\x20applied.\n\n\x0f\n\x05\x04\t\x02\x01\x04\x12\x06\xd3\x01\ + \x02\xd0\x01\x18\n\r\n\x05\x04\t\x02\x01\x05\x12\x04\xd3\x01\x02\x07\n\r\ + \n\x05\x04\t\x02\x01\x01\x12\x04\xd3\x01\x08\x0f\n\r\n\x05\x04\t\x02\x01\ + \x03\x12\x04\xd3\x01\x12\x13\n\xc7\x01\n\x04\x04\t\x02\x02\x12\x04\xd8\ + \x01\x02)\x1a\xb8\x01\x20Rules\x20specifying\x20how\x20the\x20specified\ + \x20row's\x20contents\x20are\x20to\x20be\x20transformed\n\x20into\x20wri\ + tes.\x20Entries\x20are\x20applied\x20in\x20order,\x20meaning\x20that\x20\ + earlier\x20rules\x20will\n\x20affect\x20the\x20results\x20of\x20later\ + \x20ones.\n\n\r\n\x05\x04\t\x02\x02\x04\x12\x04\xd8\x01\x02\n\n\r\n\x05\ + \x04\t\x02\x02\x06\x12\x04\xd8\x01\x0b\x1e\n\r\n\x05\x04\t\x02\x02\x01\ + \x12\x04\xd8\x01\x1f$\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xd8\x01'(b\x06\ + proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/mod.rs new file mode 100644 index 00000000..8c37a71c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v1/mod.rs @@ -0,0 +1,7 @@ +pub mod bigtable_data; +pub mod bigtable_service; +pub mod bigtable_service_grpc; +pub mod bigtable_service_messages; + +pub(crate) use crate::empty; +pub(crate) use crate::rpc::status; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable.rs new file mode 100644 index 00000000..f1dd2f42 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable.rs @@ -0,0 +1,4457 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/v2/bigtable.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub rows: ::protobuf::SingularPtrField, + pub filter: ::protobuf::SingularPtrField, + pub rows_limit: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsRequest { + fn default() -> &'a ReadRowsRequest { + ::default_instance() + } +} + +impl ReadRowsRequest { + pub fn new() -> ReadRowsRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 5; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // .google.bigtable.v2.RowSet rows = 2; + + + pub fn get_rows(&self) -> &super::data::RowSet { + self.rows.as_ref().unwrap_or_else(|| super::data::RowSet::default_instance()) + } + pub fn clear_rows(&mut self) { + self.rows.clear(); + } + + pub fn has_rows(&self) -> bool { + self.rows.is_some() + } + + // Param is passed by value, moved + pub fn set_rows(&mut self, v: super::data::RowSet) { + self.rows = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_rows(&mut self) -> &mut super::data::RowSet { + if self.rows.is_none() { + self.rows.set_default(); + } + self.rows.as_mut().unwrap() + } + + // Take field + pub fn take_rows(&mut self) -> super::data::RowSet { + self.rows.take().unwrap_or_else(|| super::data::RowSet::new()) + } + + // .google.bigtable.v2.RowFilter filter = 3; + + + pub fn get_filter(&self) -> &super::data::RowFilter { + self.filter.as_ref().unwrap_or_else(|| super::data::RowFilter::default_instance()) + } + pub fn clear_filter(&mut self) { + self.filter.clear(); + } + + pub fn has_filter(&self) -> bool { + self.filter.is_some() + } + + // Param is passed by value, moved + pub fn set_filter(&mut self, v: super::data::RowFilter) { + self.filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_filter(&mut self) -> &mut super::data::RowFilter { + if self.filter.is_none() { + self.filter.set_default(); + } + self.filter.as_mut().unwrap() + } + + // Take field + pub fn take_filter(&mut self) -> super::data::RowFilter { + self.filter.take().unwrap_or_else(|| super::data::RowFilter::new()) + } + + // int64 rows_limit = 4; + + + pub fn get_rows_limit(&self) -> i64 { + self.rows_limit + } + pub fn clear_rows_limit(&mut self) { + self.rows_limit = 0; + } + + // Param is passed by value, moved + pub fn set_rows_limit(&mut self, v: i64) { + self.rows_limit = v; + } +} + +impl ::protobuf::Message for ReadRowsRequest { + fn is_initialized(&self) -> bool { + for v in &self.rows { + if !v.is_initialized() { + return false; + } + }; + for v in &self.filter { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 5 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.rows)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.filter)?; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.rows_limit = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(5, &self.app_profile_id); + } + if let Some(ref v) = self.rows.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.rows_limit != 0 { + my_size += ::protobuf::rt::value_size(4, self.rows_limit, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(5, &self.app_profile_id)?; + } + if let Some(ref v) = self.rows.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.filter.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.rows_limit != 0 { + os.write_int64(4, self.rows_limit)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsRequest { + ReadRowsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &ReadRowsRequest| { &m.table_name }, + |m: &mut ReadRowsRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &ReadRowsRequest| { &m.app_profile_id }, + |m: &mut ReadRowsRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rows", + |m: &ReadRowsRequest| { &m.rows }, + |m: &mut ReadRowsRequest| { &mut m.rows }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filter", + |m: &ReadRowsRequest| { &m.filter }, + |m: &mut ReadRowsRequest| { &mut m.filter }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "rows_limit", + |m: &ReadRowsRequest| { &m.rows_limit }, + |m: &mut ReadRowsRequest| { &mut m.rows_limit }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsRequest, + }; + unsafe { + instance.get(ReadRowsRequest::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.rows.clear(); + self.filter.clear(); + self.rows_limit = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsResponse { + // message fields + pub chunks: ::protobuf::RepeatedField, + pub last_scanned_row_key: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsResponse { + fn default() -> &'a ReadRowsResponse { + ::default_instance() + } +} + +impl ReadRowsResponse { + pub fn new() -> ReadRowsResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v2.ReadRowsResponse.CellChunk chunks = 1; + + + pub fn get_chunks(&self) -> &[ReadRowsResponse_CellChunk] { + &self.chunks + } + pub fn clear_chunks(&mut self) { + self.chunks.clear(); + } + + // Param is passed by value, moved + pub fn set_chunks(&mut self, v: ::protobuf::RepeatedField) { + self.chunks = v; + } + + // Mutable pointer to the field. + pub fn mut_chunks(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.chunks + } + + // Take field + pub fn take_chunks(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.chunks, ::protobuf::RepeatedField::new()) + } + + // bytes last_scanned_row_key = 2; + + + pub fn get_last_scanned_row_key(&self) -> &[u8] { + &self.last_scanned_row_key + } + pub fn clear_last_scanned_row_key(&mut self) { + self.last_scanned_row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_last_scanned_row_key(&mut self, v: ::std::vec::Vec) { + self.last_scanned_row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_last_scanned_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.last_scanned_row_key + } + + // Take field + pub fn take_last_scanned_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.last_scanned_row_key, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for ReadRowsResponse { + fn is_initialized(&self) -> bool { + for v in &self.chunks { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.chunks)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.last_scanned_row_key)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.chunks { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.last_scanned_row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.last_scanned_row_key); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.chunks { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.last_scanned_row_key.is_empty() { + os.write_bytes(2, &self.last_scanned_row_key)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsResponse { + ReadRowsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "chunks", + |m: &ReadRowsResponse| { &m.chunks }, + |m: &mut ReadRowsResponse| { &mut m.chunks }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "last_scanned_row_key", + |m: &ReadRowsResponse| { &m.last_scanned_row_key }, + |m: &mut ReadRowsResponse| { &mut m.last_scanned_row_key }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsResponse, + }; + unsafe { + instance.get(ReadRowsResponse::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsResponse { + fn clear(&mut self) { + self.chunks.clear(); + self.last_scanned_row_key.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRowsResponse_CellChunk { + // message fields + pub row_key: ::std::vec::Vec, + pub family_name: ::protobuf::SingularPtrField<::protobuf::well_known_types::StringValue>, + pub qualifier: ::protobuf::SingularPtrField<::protobuf::well_known_types::BytesValue>, + pub timestamp_micros: i64, + pub labels: ::protobuf::RepeatedField<::std::string::String>, + pub value: ::std::vec::Vec, + pub value_size: i32, + // message oneof groups + pub row_status: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRowsResponse_CellChunk { + fn default() -> &'a ReadRowsResponse_CellChunk { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ReadRowsResponse_CellChunk_oneof_row_status { + reset_row(bool), + commit_row(bool), +} + +impl ReadRowsResponse_CellChunk { + pub fn new() -> ReadRowsResponse_CellChunk { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // .google.protobuf.StringValue family_name = 2; + + + pub fn get_family_name(&self) -> &::protobuf::well_known_types::StringValue { + self.family_name.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::StringValue::default_instance()) + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + pub fn has_family_name(&self) -> bool { + self.family_name.is_some() + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::protobuf::well_known_types::StringValue) { + self.family_name = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::protobuf::well_known_types::StringValue { + if self.family_name.is_none() { + self.family_name.set_default(); + } + self.family_name.as_mut().unwrap() + } + + // Take field + pub fn take_family_name(&mut self) -> ::protobuf::well_known_types::StringValue { + self.family_name.take().unwrap_or_else(|| ::protobuf::well_known_types::StringValue::new()) + } + + // .google.protobuf.BytesValue qualifier = 3; + + + pub fn get_qualifier(&self) -> &::protobuf::well_known_types::BytesValue { + self.qualifier.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::BytesValue::default_instance()) + } + pub fn clear_qualifier(&mut self) { + self.qualifier.clear(); + } + + pub fn has_qualifier(&self) -> bool { + self.qualifier.is_some() + } + + // Param is passed by value, moved + pub fn set_qualifier(&mut self, v: ::protobuf::well_known_types::BytesValue) { + self.qualifier = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_qualifier(&mut self) -> &mut ::protobuf::well_known_types::BytesValue { + if self.qualifier.is_none() { + self.qualifier.set_default(); + } + self.qualifier.as_mut().unwrap() + } + + // Take field + pub fn take_qualifier(&mut self) -> ::protobuf::well_known_types::BytesValue { + self.qualifier.take().unwrap_or_else(|| ::protobuf::well_known_types::BytesValue::new()) + } + + // int64 timestamp_micros = 4; + + + pub fn get_timestamp_micros(&self) -> i64 { + self.timestamp_micros + } + pub fn clear_timestamp_micros(&mut self) { + self.timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_timestamp_micros(&mut self, v: i64) { + self.timestamp_micros = v; + } + + // repeated string labels = 5; + + + pub fn get_labels(&self) -> &[::std::string::String] { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new()) + } + + // bytes value = 6; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } + + // int32 value_size = 7; + + + pub fn get_value_size(&self) -> i32 { + self.value_size + } + pub fn clear_value_size(&mut self) { + self.value_size = 0; + } + + // Param is passed by value, moved + pub fn set_value_size(&mut self, v: i32) { + self.value_size = v; + } + + // bool reset_row = 8; + + + pub fn get_reset_row(&self) -> bool { + match self.row_status { + ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v)) => v, + _ => false, + } + } + pub fn clear_reset_row(&mut self) { + self.row_status = ::std::option::Option::None; + } + + pub fn has_reset_row(&self) -> bool { + match self.row_status { + ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_reset_row(&mut self, v: bool) { + self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v)) + } + + // bool commit_row = 9; + + + pub fn get_commit_row(&self) -> bool { + match self.row_status { + ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v)) => v, + _ => false, + } + } + pub fn clear_commit_row(&mut self) { + self.row_status = ::std::option::Option::None; + } + + pub fn has_commit_row(&self) -> bool { + match self.row_status { + ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_commit_row(&mut self, v: bool) { + self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v)) + } +} + +impl ::protobuf::Message for ReadRowsResponse_CellChunk { + fn is_initialized(&self) -> bool { + for v in &self.family_name { + if !v.is_initialized() { + return false; + } + }; + for v in &self.qualifier { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.family_name)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.qualifier)?; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.timestamp_micros = tmp; + }, + 5 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.labels)?; + }, + 6 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.value_size = tmp; + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(is.read_bool()?)); + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(is.read_bool()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + if let Some(ref v) = self.family_name.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.qualifier.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(4, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + for value in &self.labels { + my_size += ::protobuf::rt::string_size(5, &value); + }; + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(6, &self.value); + } + if self.value_size != 0 { + my_size += ::protobuf::rt::value_size(7, self.value_size, ::protobuf::wire_format::WireTypeVarint); + } + if let ::std::option::Option::Some(ref v) = self.row_status { + match v { + &ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v) => { + my_size += 2; + }, + &ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v) => { + my_size += 2; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + if let Some(ref v) = self.family_name.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.qualifier.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.timestamp_micros != 0 { + os.write_int64(4, self.timestamp_micros)?; + } + for v in &self.labels { + os.write_string(5, &v)?; + }; + if !self.value.is_empty() { + os.write_bytes(6, &self.value)?; + } + if self.value_size != 0 { + os.write_int32(7, self.value_size)?; + } + if let ::std::option::Option::Some(ref v) = self.row_status { + match v { + &ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v) => { + os.write_bool(8, v)?; + }, + &ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v) => { + os.write_bool(9, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRowsResponse_CellChunk { + ReadRowsResponse_CellChunk::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &ReadRowsResponse_CellChunk| { &m.row_key }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::StringValue>>( + "family_name", + |m: &ReadRowsResponse_CellChunk| { &m.family_name }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::BytesValue>>( + "qualifier", + |m: &ReadRowsResponse_CellChunk| { &m.qualifier }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "timestamp_micros", + |m: &ReadRowsResponse_CellChunk| { &m.timestamp_micros }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &ReadRowsResponse_CellChunk| { &m.labels }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.labels }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &ReadRowsResponse_CellChunk| { &m.value }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.value }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "value_size", + |m: &ReadRowsResponse_CellChunk| { &m.value_size }, + |m: &mut ReadRowsResponse_CellChunk| { &mut m.value_size }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "reset_row", + ReadRowsResponse_CellChunk::has_reset_row, + ReadRowsResponse_CellChunk::get_reset_row, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "commit_row", + ReadRowsResponse_CellChunk::has_commit_row, + ReadRowsResponse_CellChunk::get_commit_row, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRowsResponse_CellChunk", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRowsResponse_CellChunk { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRowsResponse_CellChunk, + }; + unsafe { + instance.get(ReadRowsResponse_CellChunk::new) + } + } +} + +impl ::protobuf::Clear for ReadRowsResponse_CellChunk { + fn clear(&mut self) { + self.row_key.clear(); + self.family_name.clear(); + self.qualifier.clear(); + self.timestamp_micros = 0; + self.labels.clear(); + self.value.clear(); + self.value_size = 0; + self.row_status = ::std::option::Option::None; + self.row_status = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRowsResponse_CellChunk { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse_CellChunk { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SampleRowKeysRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SampleRowKeysRequest { + fn default() -> &'a SampleRowKeysRequest { + ::default_instance() + } +} + +impl SampleRowKeysRequest { + pub fn new() -> SampleRowKeysRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 2; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for SampleRowKeysRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.app_profile_id); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(2, &self.app_profile_id)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SampleRowKeysRequest { + SampleRowKeysRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &SampleRowKeysRequest| { &m.table_name }, + |m: &mut SampleRowKeysRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &SampleRowKeysRequest| { &m.app_profile_id }, + |m: &mut SampleRowKeysRequest| { &mut m.app_profile_id }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SampleRowKeysRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SampleRowKeysRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SampleRowKeysRequest, + }; + unsafe { + instance.get(SampleRowKeysRequest::new) + } + } +} + +impl ::protobuf::Clear for SampleRowKeysRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SampleRowKeysRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SampleRowKeysRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SampleRowKeysResponse { + // message fields + pub row_key: ::std::vec::Vec, + pub offset_bytes: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SampleRowKeysResponse { + fn default() -> &'a SampleRowKeysResponse { + ::default_instance() + } +} + +impl SampleRowKeysResponse { + pub fn new() -> SampleRowKeysResponse { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // int64 offset_bytes = 2; + + + pub fn get_offset_bytes(&self) -> i64 { + self.offset_bytes + } + pub fn clear_offset_bytes(&mut self) { + self.offset_bytes = 0; + } + + // Param is passed by value, moved + pub fn set_offset_bytes(&mut self, v: i64) { + self.offset_bytes = v; + } +} + +impl ::protobuf::Message for SampleRowKeysResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.offset_bytes = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + if self.offset_bytes != 0 { + my_size += ::protobuf::rt::value_size(2, self.offset_bytes, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + if self.offset_bytes != 0 { + os.write_int64(2, self.offset_bytes)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SampleRowKeysResponse { + SampleRowKeysResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &SampleRowKeysResponse| { &m.row_key }, + |m: &mut SampleRowKeysResponse| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "offset_bytes", + |m: &SampleRowKeysResponse| { &m.offset_bytes }, + |m: &mut SampleRowKeysResponse| { &mut m.offset_bytes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SampleRowKeysResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SampleRowKeysResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SampleRowKeysResponse, + }; + unsafe { + instance.get(SampleRowKeysResponse::new) + } + } +} + +impl ::protobuf::Clear for SampleRowKeysResponse { + fn clear(&mut self) { + self.row_key.clear(); + self.offset_bytes = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SampleRowKeysResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SampleRowKeysResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowRequest { + fn default() -> &'a MutateRowRequest { + ::default_instance() + } +} + +impl MutateRowRequest { + pub fn new() -> MutateRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 4; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v2.Mutation mutations = 3; + + + pub fn get_mutations(&self) -> &[super::data::Mutation] { + &self.mutations + } + pub fn clear_mutations(&mut self) { + self.mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.mutations + } + + // Take field + pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.app_profile_id); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + for value in &self.mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(4, &self.app_profile_id)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + for v in &self.mutations { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowRequest { + MutateRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &MutateRowRequest| { &m.table_name }, + |m: &mut MutateRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &MutateRowRequest| { &m.app_profile_id }, + |m: &mut MutateRowRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &MutateRowRequest| { &m.row_key }, + |m: &mut MutateRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "mutations", + |m: &MutateRowRequest| { &m.mutations }, + |m: &mut MutateRowRequest| { &mut m.mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowRequest, + }; + unsafe { + instance.get(MutateRowRequest::new) + } + } +} + +impl ::protobuf::Clear for MutateRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.row_key.clear(); + self.mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowResponse { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowResponse { + fn default() -> &'a MutateRowResponse { + ::default_instance() + } +} + +impl MutateRowResponse { + pub fn new() -> MutateRowResponse { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for MutateRowResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowResponse { + MutateRowResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowResponse, + }; + unsafe { + instance.get(MutateRowResponse::new) + } + } +} + +impl ::protobuf::Clear for MutateRowResponse { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub entries: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsRequest { + fn default() -> &'a MutateRowsRequest { + ::default_instance() + } +} + +impl MutateRowsRequest { + pub fn new() -> MutateRowsRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 3; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // repeated .google.bigtable.v2.MutateRowsRequest.Entry entries = 2; + + + pub fn get_entries(&self) -> &[MutateRowsRequest_Entry] { + &self.entries + } + pub fn clear_entries(&mut self) { + self.entries.clear(); + } + + // Param is passed by value, moved + pub fn set_entries(&mut self, v: ::protobuf::RepeatedField) { + self.entries = v; + } + + // Mutable pointer to the field. + pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.entries + } + + // Take field + pub fn take_entries(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsRequest { + fn is_initialized(&self) -> bool { + for v in &self.entries { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.app_profile_id); + } + for value in &self.entries { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(3, &self.app_profile_id)?; + } + for v in &self.entries { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsRequest { + MutateRowsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &MutateRowsRequest| { &m.table_name }, + |m: &mut MutateRowsRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &MutateRowsRequest| { &m.app_profile_id }, + |m: &mut MutateRowsRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "entries", + |m: &MutateRowsRequest| { &m.entries }, + |m: &mut MutateRowsRequest| { &mut m.entries }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsRequest, + }; + unsafe { + instance.get(MutateRowsRequest::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.entries.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsRequest_Entry { + // message fields + pub row_key: ::std::vec::Vec, + pub mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsRequest_Entry { + fn default() -> &'a MutateRowsRequest_Entry { + ::default_instance() + } +} + +impl MutateRowsRequest_Entry { + pub fn new() -> MutateRowsRequest_Entry { + ::std::default::Default::default() + } + + // bytes row_key = 1; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v2.Mutation mutations = 2; + + + pub fn get_mutations(&self) -> &[super::data::Mutation] { + &self.mutations + } + pub fn clear_mutations(&mut self) { + self.mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.mutations + } + + // Take field + pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsRequest_Entry { + fn is_initialized(&self) -> bool { + for v in &self.mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.row_key); + } + for value in &self.mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.row_key.is_empty() { + os.write_bytes(1, &self.row_key)?; + } + for v in &self.mutations { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsRequest_Entry { + MutateRowsRequest_Entry::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &MutateRowsRequest_Entry| { &m.row_key }, + |m: &mut MutateRowsRequest_Entry| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "mutations", + |m: &MutateRowsRequest_Entry| { &m.mutations }, + |m: &mut MutateRowsRequest_Entry| { &mut m.mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsRequest_Entry", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsRequest_Entry { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsRequest_Entry, + }; + unsafe { + instance.get(MutateRowsRequest_Entry::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsRequest_Entry { + fn clear(&mut self) { + self.row_key.clear(); + self.mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsRequest_Entry { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest_Entry { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsResponse { + // message fields + pub entries: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsResponse { + fn default() -> &'a MutateRowsResponse { + ::default_instance() + } +} + +impl MutateRowsResponse { + pub fn new() -> MutateRowsResponse { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v2.MutateRowsResponse.Entry entries = 1; + + + pub fn get_entries(&self) -> &[MutateRowsResponse_Entry] { + &self.entries + } + pub fn clear_entries(&mut self) { + self.entries.clear(); + } + + // Param is passed by value, moved + pub fn set_entries(&mut self, v: ::protobuf::RepeatedField) { + self.entries = v; + } + + // Mutable pointer to the field. + pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.entries + } + + // Take field + pub fn take_entries(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MutateRowsResponse { + fn is_initialized(&self) -> bool { + for v in &self.entries { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.entries { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.entries { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsResponse { + MutateRowsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "entries", + |m: &MutateRowsResponse| { &m.entries }, + |m: &mut MutateRowsResponse| { &mut m.entries }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsResponse, + }; + unsafe { + instance.get(MutateRowsResponse::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsResponse { + fn clear(&mut self) { + self.entries.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct MutateRowsResponse_Entry { + // message fields + pub index: i64, + pub status: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MutateRowsResponse_Entry { + fn default() -> &'a MutateRowsResponse_Entry { + ::default_instance() + } +} + +impl MutateRowsResponse_Entry { + pub fn new() -> MutateRowsResponse_Entry { + ::std::default::Default::default() + } + + // int64 index = 1; + + + pub fn get_index(&self) -> i64 { + self.index + } + pub fn clear_index(&mut self) { + self.index = 0; + } + + // Param is passed by value, moved + pub fn set_index(&mut self, v: i64) { + self.index = v; + } + + // .google.rpc.Status status = 2; + + + pub fn get_status(&self) -> &super::status::Status { + self.status.as_ref().unwrap_or_else(|| super::status::Status::default_instance()) + } + pub fn clear_status(&mut self) { + self.status.clear(); + } + + pub fn has_status(&self) -> bool { + self.status.is_some() + } + + // Param is passed by value, moved + pub fn set_status(&mut self, v: super::status::Status) { + self.status = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_status(&mut self) -> &mut super::status::Status { + if self.status.is_none() { + self.status.set_default(); + } + self.status.as_mut().unwrap() + } + + // Take field + pub fn take_status(&mut self) -> super::status::Status { + self.status.take().unwrap_or_else(|| super::status::Status::new()) + } +} + +impl ::protobuf::Message for MutateRowsResponse_Entry { + fn is_initialized(&self) -> bool { + for v in &self.status { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.index = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.status)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.index != 0 { + my_size += ::protobuf::rt::value_size(1, self.index, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(ref v) = self.status.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.index != 0 { + os.write_int64(1, self.index)?; + } + if let Some(ref v) = self.status.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MutateRowsResponse_Entry { + MutateRowsResponse_Entry::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "index", + |m: &MutateRowsResponse_Entry| { &m.index }, + |m: &mut MutateRowsResponse_Entry| { &mut m.index }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "status", + |m: &MutateRowsResponse_Entry| { &m.status }, + |m: &mut MutateRowsResponse_Entry| { &mut m.status }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MutateRowsResponse_Entry", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MutateRowsResponse_Entry { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MutateRowsResponse_Entry, + }; + unsafe { + instance.get(MutateRowsResponse_Entry::new) + } + } +} + +impl ::protobuf::Clear for MutateRowsResponse_Entry { + fn clear(&mut self) { + self.index = 0; + self.status.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MutateRowsResponse_Entry { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MutateRowsResponse_Entry { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckAndMutateRowRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub predicate_filter: ::protobuf::SingularPtrField, + pub true_mutations: ::protobuf::RepeatedField, + pub false_mutations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckAndMutateRowRequest { + fn default() -> &'a CheckAndMutateRowRequest { + ::default_instance() + } +} + +impl CheckAndMutateRowRequest { + pub fn new() -> CheckAndMutateRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 7; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // .google.bigtable.v2.RowFilter predicate_filter = 6; + + + pub fn get_predicate_filter(&self) -> &super::data::RowFilter { + self.predicate_filter.as_ref().unwrap_or_else(|| super::data::RowFilter::default_instance()) + } + pub fn clear_predicate_filter(&mut self) { + self.predicate_filter.clear(); + } + + pub fn has_predicate_filter(&self) -> bool { + self.predicate_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_predicate_filter(&mut self, v: super::data::RowFilter) { + self.predicate_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_predicate_filter(&mut self) -> &mut super::data::RowFilter { + if self.predicate_filter.is_none() { + self.predicate_filter.set_default(); + } + self.predicate_filter.as_mut().unwrap() + } + + // Take field + pub fn take_predicate_filter(&mut self) -> super::data::RowFilter { + self.predicate_filter.take().unwrap_or_else(|| super::data::RowFilter::new()) + } + + // repeated .google.bigtable.v2.Mutation true_mutations = 4; + + + pub fn get_true_mutations(&self) -> &[super::data::Mutation] { + &self.true_mutations + } + pub fn clear_true_mutations(&mut self) { + self.true_mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_true_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.true_mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_true_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.true_mutations + } + + // Take field + pub fn take_true_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.true_mutations, ::protobuf::RepeatedField::new()) + } + + // repeated .google.bigtable.v2.Mutation false_mutations = 5; + + + pub fn get_false_mutations(&self) -> &[super::data::Mutation] { + &self.false_mutations + } + pub fn clear_false_mutations(&mut self) { + self.false_mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_false_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.false_mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_false_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.false_mutations + } + + // Take field + pub fn take_false_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.false_mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CheckAndMutateRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.predicate_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.true_mutations { + if !v.is_initialized() { + return false; + } + }; + for v in &self.false_mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 7 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.predicate_filter)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.true_mutations)?; + }, + 5 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.false_mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(7, &self.app_profile_id); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + if let Some(ref v) = self.predicate_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.true_mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.false_mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(7, &self.app_profile_id)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + if let Some(ref v) = self.predicate_filter.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.true_mutations { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.false_mutations { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckAndMutateRowRequest { + CheckAndMutateRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &CheckAndMutateRowRequest| { &m.table_name }, + |m: &mut CheckAndMutateRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &CheckAndMutateRowRequest| { &m.app_profile_id }, + |m: &mut CheckAndMutateRowRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &CheckAndMutateRowRequest| { &m.row_key }, + |m: &mut CheckAndMutateRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "predicate_filter", + |m: &CheckAndMutateRowRequest| { &m.predicate_filter }, + |m: &mut CheckAndMutateRowRequest| { &mut m.predicate_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "true_mutations", + |m: &CheckAndMutateRowRequest| { &m.true_mutations }, + |m: &mut CheckAndMutateRowRequest| { &mut m.true_mutations }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "false_mutations", + |m: &CheckAndMutateRowRequest| { &m.false_mutations }, + |m: &mut CheckAndMutateRowRequest| { &mut m.false_mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckAndMutateRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckAndMutateRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckAndMutateRowRequest, + }; + unsafe { + instance.get(CheckAndMutateRowRequest::new) + } + } +} + +impl ::protobuf::Clear for CheckAndMutateRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.row_key.clear(); + self.predicate_filter.clear(); + self.true_mutations.clear(); + self.false_mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckAndMutateRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CheckAndMutateRowResponse { + // message fields + pub predicate_matched: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CheckAndMutateRowResponse { + fn default() -> &'a CheckAndMutateRowResponse { + ::default_instance() + } +} + +impl CheckAndMutateRowResponse { + pub fn new() -> CheckAndMutateRowResponse { + ::std::default::Default::default() + } + + // bool predicate_matched = 1; + + + pub fn get_predicate_matched(&self) -> bool { + self.predicate_matched + } + pub fn clear_predicate_matched(&mut self) { + self.predicate_matched = false; + } + + // Param is passed by value, moved + pub fn set_predicate_matched(&mut self, v: bool) { + self.predicate_matched = v; + } +} + +impl ::protobuf::Message for CheckAndMutateRowResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.predicate_matched = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.predicate_matched != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.predicate_matched != false { + os.write_bool(1, self.predicate_matched)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CheckAndMutateRowResponse { + CheckAndMutateRowResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "predicate_matched", + |m: &CheckAndMutateRowResponse| { &m.predicate_matched }, + |m: &mut CheckAndMutateRowResponse| { &mut m.predicate_matched }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CheckAndMutateRowResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CheckAndMutateRowResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CheckAndMutateRowResponse, + }; + unsafe { + instance.get(CheckAndMutateRowResponse::new) + } + } +} + +impl ::protobuf::Clear for CheckAndMutateRowResponse { + fn clear(&mut self) { + self.predicate_matched = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CheckAndMutateRowResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadModifyWriteRowRequest { + // message fields + pub table_name: ::std::string::String, + pub app_profile_id: ::std::string::String, + pub row_key: ::std::vec::Vec, + pub rules: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadModifyWriteRowRequest { + fn default() -> &'a ReadModifyWriteRowRequest { + ::default_instance() + } +} + +impl ReadModifyWriteRowRequest { + pub fn new() -> ReadModifyWriteRowRequest { + ::std::default::Default::default() + } + + // string table_name = 1; + + + pub fn get_table_name(&self) -> &str { + &self.table_name + } + pub fn clear_table_name(&mut self) { + self.table_name.clear(); + } + + // Param is passed by value, moved + pub fn set_table_name(&mut self, v: ::std::string::String) { + self.table_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table_name(&mut self) -> &mut ::std::string::String { + &mut self.table_name + } + + // Take field + pub fn take_table_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table_name, ::std::string::String::new()) + } + + // string app_profile_id = 4; + + + pub fn get_app_profile_id(&self) -> &str { + &self.app_profile_id + } + pub fn clear_app_profile_id(&mut self) { + self.app_profile_id.clear(); + } + + // Param is passed by value, moved + pub fn set_app_profile_id(&mut self, v: ::std::string::String) { + self.app_profile_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String { + &mut self.app_profile_id + } + + // Take field + pub fn take_app_profile_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new()) + } + + // bytes row_key = 2; + + + pub fn get_row_key(&self) -> &[u8] { + &self.row_key + } + pub fn clear_row_key(&mut self) { + self.row_key.clear(); + } + + // Param is passed by value, moved + pub fn set_row_key(&mut self, v: ::std::vec::Vec) { + self.row_key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.row_key + } + + // Take field + pub fn take_row_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v2.ReadModifyWriteRule rules = 3; + + + pub fn get_rules(&self) -> &[super::data::ReadModifyWriteRule] { + &self.rules + } + pub fn clear_rules(&mut self) { + self.rules.clear(); + } + + // Param is passed by value, moved + pub fn set_rules(&mut self, v: ::protobuf::RepeatedField) { + self.rules = v; + } + + // Mutable pointer to the field. + pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.rules + } + + // Take field + pub fn take_rules(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ReadModifyWriteRowRequest { + fn is_initialized(&self) -> bool { + for v in &self.rules { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table_name); + } + if !self.app_profile_id.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.app_profile_id); + } + if !self.row_key.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.row_key); + } + for value in &self.rules { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table_name.is_empty() { + os.write_string(1, &self.table_name)?; + } + if !self.app_profile_id.is_empty() { + os.write_string(4, &self.app_profile_id)?; + } + if !self.row_key.is_empty() { + os.write_bytes(2, &self.row_key)?; + } + for v in &self.rules { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadModifyWriteRowRequest { + ReadModifyWriteRowRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table_name", + |m: &ReadModifyWriteRowRequest| { &m.table_name }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.table_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "app_profile_id", + |m: &ReadModifyWriteRowRequest| { &m.app_profile_id }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.app_profile_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_key", + |m: &ReadModifyWriteRowRequest| { &m.row_key }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.row_key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "rules", + |m: &ReadModifyWriteRowRequest| { &m.rules }, + |m: &mut ReadModifyWriteRowRequest| { &mut m.rules }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadModifyWriteRowRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadModifyWriteRowRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadModifyWriteRowRequest, + }; + unsafe { + instance.get(ReadModifyWriteRowRequest::new) + } + } +} + +impl ::protobuf::Clear for ReadModifyWriteRowRequest { + fn clear(&mut self) { + self.table_name.clear(); + self.app_profile_id.clear(); + self.row_key.clear(); + self.rules.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadModifyWriteRowRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRowRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadModifyWriteRowResponse { + // message fields + pub row: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadModifyWriteRowResponse { + fn default() -> &'a ReadModifyWriteRowResponse { + ::default_instance() + } +} + +impl ReadModifyWriteRowResponse { + pub fn new() -> ReadModifyWriteRowResponse { + ::std::default::Default::default() + } + + // .google.bigtable.v2.Row row = 1; + + + pub fn get_row(&self) -> &super::data::Row { + self.row.as_ref().unwrap_or_else(|| super::data::Row::default_instance()) + } + pub fn clear_row(&mut self) { + self.row.clear(); + } + + pub fn has_row(&self) -> bool { + self.row.is_some() + } + + // Param is passed by value, moved + pub fn set_row(&mut self, v: super::data::Row) { + self.row = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row(&mut self) -> &mut super::data::Row { + if self.row.is_none() { + self.row.set_default(); + } + self.row.as_mut().unwrap() + } + + // Take field + pub fn take_row(&mut self) -> super::data::Row { + self.row.take().unwrap_or_else(|| super::data::Row::new()) + } +} + +impl ::protobuf::Message for ReadModifyWriteRowResponse { + fn is_initialized(&self) -> bool { + for v in &self.row { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.row)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.row.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.row.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadModifyWriteRowResponse { + ReadModifyWriteRowResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "row", + |m: &ReadModifyWriteRowResponse| { &m.row }, + |m: &mut ReadModifyWriteRowResponse| { &mut m.row }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadModifyWriteRowResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadModifyWriteRowResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadModifyWriteRowResponse, + }; + unsafe { + instance.get(ReadModifyWriteRowResponse::new) + } + } +} + +impl ::protobuf::Clear for ReadModifyWriteRowResponse { + fn clear(&mut self) { + self.row.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadModifyWriteRowResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRowResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n!google/bigtable/v2/bigtable.proto\x12\x12google.bigtable.v2\x1a\x1cgo\ + ogle/api/annotations.proto\x1a\x1dgoogle/bigtable/v2/data.proto\x1a\x1eg\ + oogle/protobuf/wrappers.proto\x1a\x17google/rpc/status.proto\"\xdc\x01\n\ + \x0fReadRowsRequest\x12\x1d\n\ntable_name\x18\x01\x20\x01(\tR\ttableName\ + \x12$\n\x0eapp_profile_id\x18\x05\x20\x01(\tR\x0cappProfileId\x12.\n\x04\ + rows\x18\x02\x20\x01(\x0b2\x1a.google.bigtable.v2.RowSetR\x04rows\x125\n\ + \x06filter\x18\x03\x20\x01(\x0b2\x1d.google.bigtable.v2.RowFilterR\x06fi\ + lter\x12\x1d\n\nrows_limit\x18\x04\x20\x01(\x03R\trowsLimit\"\xf2\x03\n\ + \x10ReadRowsResponse\x12F\n\x06chunks\x18\x01\x20\x03(\x0b2..google.bigt\ + able.v2.ReadRowsResponse.CellChunkR\x06chunks\x12/\n\x14last_scanned_row\ + _key\x18\x02\x20\x01(\x0cR\x11lastScannedRowKey\x1a\xe4\x02\n\tCellChunk\ + \x12\x17\n\x07row_key\x18\x01\x20\x01(\x0cR\x06rowKey\x12=\n\x0bfamily_n\ + ame\x18\x02\x20\x01(\x0b2\x1c.google.protobuf.StringValueR\nfamilyName\ + \x129\n\tqualifier\x18\x03\x20\x01(\x0b2\x1b.google.protobuf.BytesValueR\ + \tqualifier\x12)\n\x10timestamp_micros\x18\x04\x20\x01(\x03R\x0ftimestam\ + pMicros\x12\x16\n\x06labels\x18\x05\x20\x03(\tR\x06labels\x12\x14\n\x05v\ + alue\x18\x06\x20\x01(\x0cR\x05value\x12\x1d\n\nvalue_size\x18\x07\x20\ + \x01(\x05R\tvalueSize\x12\x1d\n\treset_row\x18\x08\x20\x01(\x08H\0R\x08r\ + esetRow\x12\x1f\n\ncommit_row\x18\t\x20\x01(\x08H\0R\tcommitRowB\x0c\n\n\ + row_status\"[\n\x14SampleRowKeysRequest\x12\x1d\n\ntable_name\x18\x01\ + \x20\x01(\tR\ttableName\x12$\n\x0eapp_profile_id\x18\x02\x20\x01(\tR\x0c\ + appProfileId\"S\n\x15SampleRowKeysResponse\x12\x17\n\x07row_key\x18\x01\ + \x20\x01(\x0cR\x06rowKey\x12!\n\x0coffset_bytes\x18\x02\x20\x01(\x03R\ + \x0boffsetBytes\"\xac\x01\n\x10MutateRowRequest\x12\x1d\n\ntable_name\ + \x18\x01\x20\x01(\tR\ttableName\x12$\n\x0eapp_profile_id\x18\x04\x20\x01\ + (\tR\x0cappProfileId\x12\x17\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKe\ + y\x12:\n\tmutations\x18\x03\x20\x03(\x0b2\x1c.google.bigtable.v2.Mutatio\ + nR\tmutations\"\x13\n\x11MutateRowResponse\"\xfd\x01\n\x11MutateRowsRequ\ + est\x12\x1d\n\ntable_name\x18\x01\x20\x01(\tR\ttableName\x12$\n\x0eapp_p\ + rofile_id\x18\x03\x20\x01(\tR\x0cappProfileId\x12E\n\x07entries\x18\x02\ + \x20\x03(\x0b2+.google.bigtable.v2.MutateRowsRequest.EntryR\x07entries\ + \x1a\\\n\x05Entry\x12\x17\n\x07row_key\x18\x01\x20\x01(\x0cR\x06rowKey\ + \x12:\n\tmutations\x18\x02\x20\x03(\x0b2\x1c.google.bigtable.v2.Mutation\ + R\tmutations\"\xa7\x01\n\x12MutateRowsResponse\x12F\n\x07entries\x18\x01\ + \x20\x03(\x0b2,.google.bigtable.v2.MutateRowsResponse.EntryR\x07entries\ + \x1aI\n\x05Entry\x12\x14\n\x05index\x18\x01\x20\x01(\x03R\x05index\x12*\ + \n\x06status\x18\x02\x20\x01(\x0b2\x12.google.rpc.StatusR\x06status\"\ + \xce\x02\n\x18CheckAndMutateRowRequest\x12\x1d\n\ntable_name\x18\x01\x20\ + \x01(\tR\ttableName\x12$\n\x0eapp_profile_id\x18\x07\x20\x01(\tR\x0cappP\ + rofileId\x12\x17\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKey\x12H\n\x10\ + predicate_filter\x18\x06\x20\x01(\x0b2\x1d.google.bigtable.v2.RowFilterR\ + \x0fpredicateFilter\x12C\n\x0etrue_mutations\x18\x04\x20\x03(\x0b2\x1c.g\ + oogle.bigtable.v2.MutationR\rtrueMutations\x12E\n\x0ffalse_mutations\x18\ + \x05\x20\x03(\x0b2\x1c.google.bigtable.v2.MutationR\x0efalseMutations\"H\ + \n\x19CheckAndMutateRowResponse\x12+\n\x11predicate_matched\x18\x01\x20\ + \x01(\x08R\x10predicateMatched\"\xb8\x01\n\x19ReadModifyWriteRowRequest\ + \x12\x1d\n\ntable_name\x18\x01\x20\x01(\tR\ttableName\x12$\n\x0eapp_prof\ + ile_id\x18\x04\x20\x01(\tR\x0cappProfileId\x12\x17\n\x07row_key\x18\x02\ + \x20\x01(\x0cR\x06rowKey\x12=\n\x05rules\x18\x03\x20\x03(\x0b2'.google.b\ + igtable.v2.ReadModifyWriteRuleR\x05rules\"G\n\x1aReadModifyWriteRowRespo\ + nse\x12)\n\x03row\x18\x01\x20\x01(\x0b2\x17.google.bigtable.v2.RowR\x03r\ + ow2\xad\x08\n\x08Bigtable\x12\x9d\x01\n\x08ReadRows\x12#.google.bigtable\ + .v2.ReadRowsRequest\x1a$.google.bigtable.v2.ReadRowsResponse\"D\x82\xd3\ + \xe4\x93\x02>\"9/v2/{table_name=projects/*/instances/*/tables/*}:readRow\ + s:\x01*0\x01\x12\xae\x01\n\rSampleRowKeys\x12(.google.bigtable.v2.Sample\ + RowKeysRequest\x1a).google.bigtable.v2.SampleRowKeysResponse\"F\x82\xd3\ + \xe4\x93\x02@\x12>/v2/{table_name=projects/*/instances/*/tables/*}:sampl\ + eRowKeys0\x01\x12\x9f\x01\n\tMutateRow\x12$.google.bigtable.v2.MutateRow\ + Request\x1a%.google.bigtable.v2.MutateRowResponse\"E\x82\xd3\xe4\x93\x02\ + ?\":/v2/{table_name=projects/*/instances/*/tables/*}:mutateRow:\x01*\x12\ + \xa5\x01\n\nMutateRows\x12%.google.bigtable.v2.MutateRowsRequest\x1a&.go\ + ogle.bigtable.v2.MutateRowsResponse\"F\x82\xd3\xe4\x93\x02@\";/v2/{table\ + _name=projects/*/instances/*/tables/*}:mutateRows:\x01*0\x01\x12\xbf\x01\ + \n\x11CheckAndMutateRow\x12,.google.bigtable.v2.CheckAndMutateRowRequest\ + \x1a-.google.bigtable.v2.CheckAndMutateRowResponse\"M\x82\xd3\xe4\x93\ + \x02G\"B/v2/{table_name=projects/*/instances/*/tables/*}:checkAndMutateR\ + ow:\x01*\x12\xc3\x01\n\x12ReadModifyWriteRow\x12-.google.bigtable.v2.Rea\ + dModifyWriteRowRequest\x1a..google.bigtable.v2.ReadModifyWriteRowRespons\ + e\"N\x82\xd3\xe4\x93\x02H\"C/v2/{table_name=projects/*/instances/*/table\ + s/*}:readModifyWriteRow:\x01*B\x9b\x01\n\x16com.google.bigtable.v2B\rBig\ + tableProtoP\x01Z:google.golang.org/genproto/googleapis/bigtable/v2;bigta\ + ble\xaa\x02\x18Google.Cloud.Bigtable.V2\xca\x02\x18Google\\Cloud\\Bigtab\ + le\\V2J\xabv\n\x07\x12\x05\x0e\0\xec\x02\x01\n\xbd\x04\n\x01\x0c\x12\x03\ + \x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\n\x20Licens\ + ed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"\ + License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\x20i\ + n\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20\ + a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://ww\ + w.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20app\ + licable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20\ + distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\ + \x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITION\ + S\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\ + \x20the\x20License\x20for\x20the\x20specific\x20language\x20governing\ + \x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\n\n\ + \x08\n\x01\x02\x12\x03\x10\0\x1b\n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\ + \x02\x03\x01\x12\x03\x13\0'\n\t\n\x02\x03\x02\x12\x03\x14\0(\n\t\n\x02\ + \x03\x03\x12\x03\x15\0!\n\x08\n\x01\x08\x12\x03\x17\05\n\t\n\x02\x08%\ + \x12\x03\x17\05\n\x08\n\x01\x08\x12\x03\x18\0Q\n\t\n\x02\x08\x0b\x12\x03\ + \x18\0Q\n\x08\n\x01\x08\x12\x03\x19\0\"\n\t\n\x02\x08\n\x12\x03\x19\0\"\ + \n\x08\n\x01\x08\x12\x03\x1a\0.\n\t\n\x02\x08\x08\x12\x03\x1a\0.\n\x08\n\ + \x01\x08\x12\x03\x1b\0/\n\t\n\x02\x08\x01\x12\x03\x1b\0/\n\x08\n\x01\x08\ + \x12\x03\x1c\05\n\t\n\x02\x08)\x12\x03\x1c\05\nO\n\x02\x06\0\x12\x04\x20\ + \0]\x01\x1aC\x20Service\x20for\x20reading\x20from\x20and\x20writing\x20t\ + o\x20existing\x20Bigtable\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03\x20\ + \x08\x10\n\xc1\x02\n\x04\x06\0\x02\0\x12\x04&\x02+\x03\x1a\xb2\x02\x20St\ + reams\x20back\x20the\x20contents\x20of\x20all\x20requested\x20rows\x20in\ + \x20key\x20order,\x20optionally\n\x20applying\x20the\x20same\x20Reader\ + \x20filter\x20to\x20each.\x20Depending\x20on\x20their\x20size,\n\x20rows\ + \x20and\x20cells\x20may\x20be\x20broken\x20up\x20across\x20multiple\x20r\ + esponses,\x20but\n\x20atomicity\x20of\x20each\x20row\x20will\x20still\ + \x20be\x20preserved.\x20See\x20the\n\x20ReadRowsResponse\x20documentatio\ + n\x20for\x20details.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03&\x06\x0e\n\ + \x0c\n\x05\x06\0\x02\0\x02\x12\x03&\x0f\x1e\n\x0c\n\x05\x06\0\x02\0\x06\ + \x12\x03&)/\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03&0@\n\r\n\x05\x06\0\x02\0\ + \x04\x12\x04'\x04*\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04'\ + \x04*\x06\n\xed\x01\n\x04\x06\0\x02\x01\x12\x041\x025\x03\x1a\xde\x01\ + \x20Returns\x20a\x20sample\x20of\x20row\x20keys\x20in\x20the\x20table.\ + \x20The\x20returned\x20row\x20keys\x20will\n\x20delimit\x20contiguous\ + \x20sections\x20of\x20the\x20table\x20of\x20approximately\x20equal\x20si\ + ze,\n\x20which\x20can\x20be\x20used\x20to\x20break\x20up\x20the\x20data\ + \x20for\x20distributed\x20tasks\x20like\n\x20mapreduces.\n\n\x0c\n\x05\ + \x06\0\x02\x01\x01\x12\x031\x06\x13\n\x0c\n\x05\x06\0\x02\x01\x02\x12\ + \x031\x14(\n\x0c\n\x05\x06\0\x02\x01\x06\x12\x03139\n\x0c\n\x05\x06\0\ + \x02\x01\x03\x12\x031:O\n\r\n\x05\x06\0\x02\x01\x04\x12\x042\x044\x06\n\ + \x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x042\x044\x06\n\x87\x01\n\ + \x04\x06\0\x02\x02\x12\x049\x02>\x03\x1ay\x20Mutates\x20a\x20row\x20atom\ + ically.\x20Cells\x20already\x20present\x20in\x20the\x20row\x20are\x20lef\ + t\n\x20unchanged\x20unless\x20explicitly\x20changed\x20by\x20`mutation`.\ + \n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x039\x06\x0f\n\x0c\n\x05\x06\0\x02\ + \x02\x02\x12\x039\x10\x20\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x039+<\n\r\n\ + \x05\x06\0\x02\x02\x04\x12\x04:\x04=\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\ + \xca\xbc\"\x12\x04:\x04=\x06\n\xa0\x01\n\x04\x06\0\x02\x03\x12\x04C\x02H\ + \x03\x1a\x91\x01\x20Mutates\x20multiple\x20rows\x20in\x20a\x20batch.\x20\ + Each\x20individual\x20row\x20is\x20mutated\n\x20atomically\x20as\x20in\ + \x20MutateRow,\x20but\x20the\x20entire\x20batch\x20is\x20not\x20executed\ + \n\x20atomically.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03C\x06\x10\n\x0c\ + \n\x05\x06\0\x02\x03\x02\x12\x03C\x11\"\n\x0c\n\x05\x06\0\x02\x03\x06\ + \x12\x03C-3\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03C4F\n\r\n\x05\x06\0\x02\ + \x03\x04\x12\x04D\x04G\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\ + \x04D\x04G\x06\nZ\n\x04\x06\0\x02\x04\x12\x04K\x02P\x03\x1aL\x20Mutates\ + \x20a\x20row\x20atomically\x20based\x20on\x20the\x20output\x20of\x20a\ + \x20predicate\x20Reader\x20filter.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\ + \x03K\x06\x17\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03K\x180\n\x0c\n\x05\ + \x06\0\x02\x04\x03\x12\x03K;T\n\r\n\x05\x06\0\x02\x04\x04\x12\x04L\x04O\ + \x06\n\x11\n\t\x06\0\x02\x04\x04\xb0\xca\xbc\"\x12\x04L\x04O\x06\n\xf6\ + \x02\n\x04\x06\0\x02\x05\x12\x04W\x02\\\x03\x1a\xe7\x02\x20Modifies\x20a\ + \x20row\x20atomically\x20on\x20the\x20server.\x20The\x20method\x20reads\ + \x20the\x20latest\n\x20existing\x20timestamp\x20and\x20value\x20from\x20\ + the\x20specified\x20columns\x20and\x20writes\x20a\x20new\n\x20entry\x20b\ + ased\x20on\x20pre-defined\x20read/modify/write\x20rules.\x20The\x20new\ + \x20value\x20for\x20the\n\x20timestamp\x20is\x20the\x20greater\x20of\x20\ + the\x20existing\x20timestamp\x20or\x20the\x20current\x20server\n\x20time\ + .\x20The\x20method\x20returns\x20the\x20new\x20contents\x20of\x20all\x20\ + modified\x20cells.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03W\x06\x18\n\ + \x0c\n\x05\x06\0\x02\x05\x02\x12\x03W\x192\n\x0c\n\x05\x06\0\x02\x05\x03\ + \x12\x03W=W\n\r\n\x05\x06\0\x02\x05\x04\x12\x04X\x04[\x06\n\x11\n\t\x06\ + \0\x02\x05\x04\xb0\xca\xbc\"\x12\x04X\x04[\x06\n4\n\x02\x04\0\x12\x04`\0\ + t\x01\x1a(\x20Request\x20message\x20for\x20Bigtable.ReadRows.\n\n\n\n\ + \x03\x04\0\x01\x12\x03`\x08\x17\n\x93\x01\n\x04\x04\0\x02\0\x12\x03d\x02\ + \x18\x1a\x85\x01\x20The\x20unique\x20name\x20of\x20the\x20table\x20from\ + \x20which\x20to\x20read.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`p\ + rojects//instances//tables/
`.\n\n\r\n\x05\x04\ + \0\x02\0\x04\x12\x04d\x02`\x19\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03d\x02\ + \x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03d\t\x13\n\x0c\n\x05\x04\0\x02\0\ + \x03\x12\x03d\x16\x17\n\x7f\n\x04\x04\0\x02\x01\x12\x03h\x02\x1c\x1ar\ + \x20This\x20value\x20specifies\x20routing\x20for\x20replication.\x20If\ + \x20not\x20specified,\x20the\n\x20\"default\"\x20application\x20profile\ + \x20will\x20be\x20used.\n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04h\x02d\x18\ + \n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03h\x02\x08\n\x0c\n\x05\x04\0\x02\ + \x01\x01\x12\x03h\t\x17\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03h\x1a\x1b\n\ + Y\n\x04\x04\0\x02\x02\x12\x03k\x02\x12\x1aL\x20The\x20row\x20keys\x20and\ + /or\x20ranges\x20to\x20read.\x20If\x20not\x20specified,\x20reads\x20from\ + \x20all\x20rows.\n\n\r\n\x05\x04\0\x02\x02\x04\x12\x04k\x02h\x1c\n\x0c\n\ + \x05\x04\0\x02\x02\x06\x12\x03k\x02\x08\n\x0c\n\x05\x04\0\x02\x02\x01\ + \x12\x03k\t\r\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03k\x10\x11\nv\n\x04\ + \x04\0\x02\x03\x12\x03o\x02\x17\x1ai\x20The\x20filter\x20to\x20apply\x20\ + to\x20the\x20contents\x20of\x20the\x20specified\x20row(s).\x20If\x20unse\ + t,\n\x20reads\x20the\x20entirety\x20of\x20each\x20row.\n\n\r\n\x05\x04\0\ + \x02\x03\x04\x12\x04o\x02k\x12\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03o\ + \x02\x0b\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03o\x0c\x12\n\x0c\n\x05\x04\ + \0\x02\x03\x03\x12\x03o\x15\x16\n\x82\x01\n\x04\x04\0\x02\x04\x12\x03s\ + \x02\x17\x1au\x20The\x20read\x20will\x20terminate\x20after\x20committing\ + \x20to\x20N\x20rows'\x20worth\x20of\x20results.\x20The\n\x20default\x20(\ + zero)\x20is\x20to\x20return\x20all\x20results.\n\n\r\n\x05\x04\0\x02\x04\ + \x04\x12\x04s\x02o\x17\n\x0c\n\x05\x04\0\x02\x04\x05\x12\x03s\x02\x07\n\ + \x0c\n\x05\x04\0\x02\x04\x01\x12\x03s\x08\x12\n\x0c\n\x05\x04\0\x02\x04\ + \x03\x12\x03s\x15\x16\n6\n\x02\x04\x01\x12\x05w\0\xc1\x01\x01\x1a)\x20Re\ + sponse\x20message\x20for\x20Bigtable.ReadRows.\n\n\n\n\x03\x04\x01\x01\ + \x12\x03w\x08\x18\ne\n\x04\x04\x01\x03\0\x12\x05z\x02\xb5\x01\x03\x1aV\ + \x20Specifies\x20a\x20piece\x20of\x20a\x20row's\x20contents\x20returned\ + \x20as\x20part\x20of\x20the\x20read\n\x20response\x20stream.\n\n\x0c\n\ + \x05\x04\x01\x03\0\x01\x12\x03z\n\x13\n\xf8\x01\n\x06\x04\x01\x03\0\x02\ + \0\x12\x03\x7f\x04\x16\x1a\xe8\x01\x20The\x20row\x20key\x20for\x20this\ + \x20chunk\x20of\x20data.\x20\x20If\x20the\x20row\x20key\x20is\x20empty,\ + \n\x20this\x20CellChunk\x20is\x20a\x20continuation\x20of\x20the\x20same\ + \x20row\x20as\x20the\x20previous\n\x20CellChunk\x20in\x20the\x20response\ + \x20stream,\x20even\x20if\x20that\x20CellChunk\x20was\x20in\x20a\n\x20pr\ + evious\x20ReadRowsResponse\x20message.\n\n\x0f\n\x07\x04\x01\x03\0\x02\0\ + \x04\x12\x04\x7f\x04z\x15\n\x0e\n\x07\x04\x01\x03\0\x02\0\x05\x12\x03\ + \x7f\x04\t\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\x03\x7f\n\x11\n\x0e\n\ + \x07\x04\x01\x03\0\x02\0\x03\x12\x03\x7f\x14\x15\n\xf3\x02\n\x06\x04\x01\ + \x03\0\x02\x01\x12\x04\x87\x01\x040\x1a\xe2\x02\x20The\x20column\x20fami\ + ly\x20name\x20for\x20this\x20chunk\x20of\x20data.\x20\x20If\x20this\x20m\ + essage\n\x20is\x20not\x20present\x20this\x20CellChunk\x20is\x20a\x20cont\ + inuation\x20of\x20the\x20same\x20column\n\x20family\x20as\x20the\x20prev\ + ious\x20CellChunk.\x20\x20The\x20empty\x20string\x20can\x20occur\x20as\ + \x20a\n\x20column\x20family\x20name\x20in\x20a\x20response\x20so\x20clie\ + nts\x20must\x20check\n\x20explicitly\x20for\x20the\x20presence\x20of\x20\ + this\x20message,\x20not\x20just\x20for\n\x20`family_name.value`\x20being\ + \x20non-empty.\n\n\x10\n\x07\x04\x01\x03\0\x02\x01\x04\x12\x05\x87\x01\ + \x04\x7f\x16\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x06\x12\x04\x87\x01\x04\ + \x1f\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x01\x12\x04\x87\x01\x20+\n\x0f\n\ + \x07\x04\x01\x03\0\x02\x01\x03\x12\x04\x87\x01./\n\xbb\x02\n\x06\x04\x01\ + \x03\0\x02\x02\x12\x04\x8e\x01\x04-\x1a\xaa\x02\x20The\x20column\x20qual\ + ifier\x20for\x20this\x20chunk\x20of\x20data.\x20\x20If\x20this\x20messag\ + e\n\x20is\x20not\x20present,\x20this\x20CellChunk\x20is\x20a\x20continua\ + tion\x20of\x20the\x20same\x20column\n\x20as\x20the\x20previous\x20CellCh\ + unk.\x20\x20Column\x20qualifiers\x20may\x20be\x20empty\x20so\n\x20client\ + s\x20must\x20check\x20for\x20the\x20presence\x20of\x20this\x20message,\ + \x20not\x20just\n\x20for\x20`qualifier.value`\x20being\x20non-empty.\n\n\ + \x11\n\x07\x04\x01\x03\0\x02\x02\x04\x12\x06\x8e\x01\x04\x87\x010\n\x0f\ + \n\x07\x04\x01\x03\0\x02\x02\x06\x12\x04\x8e\x01\x04\x1e\n\x0f\n\x07\x04\ + \x01\x03\0\x02\x02\x01\x12\x04\x8e\x01\x1f(\n\x0f\n\x07\x04\x01\x03\0\ + \x02\x02\x03\x12\x04\x8e\x01+,\n\xdd\x03\n\x06\x04\x01\x03\0\x02\x03\x12\ + \x04\x98\x01\x04\x1f\x1a\xcc\x03\x20The\x20cell's\x20stored\x20timestamp\ + ,\x20which\x20also\x20uniquely\x20identifies\x20it\n\x20within\x20its\ + \x20column.\x20\x20Values\x20are\x20always\x20expressed\x20in\n\x20micro\ + seconds,\x20but\x20individual\x20tables\x20may\x20set\x20a\x20coarser\n\ + \x20granularity\x20to\x20further\x20restrict\x20the\x20allowed\x20values\ + .\x20For\n\x20example,\x20a\x20table\x20which\x20specifies\x20millisecon\ + d\x20granularity\x20will\n\x20only\x20allow\x20values\x20of\x20`timestam\ + p_micros`\x20which\x20are\x20multiples\x20of\n\x201000.\x20\x20Timestamp\ + s\x20are\x20only\x20set\x20in\x20the\x20first\x20CellChunk\x20per\x20cel\ + l\n\x20(for\x20cells\x20split\x20into\x20multiple\x20chunks).\n\n\x11\n\ + \x07\x04\x01\x03\0\x02\x03\x04\x12\x06\x98\x01\x04\x8e\x01-\n\x0f\n\x07\ + \x04\x01\x03\0\x02\x03\x05\x12\x04\x98\x01\x04\t\n\x0f\n\x07\x04\x01\x03\ + \0\x02\x03\x01\x12\x04\x98\x01\n\x1a\n\x0f\n\x07\x04\x01\x03\0\x02\x03\ + \x03\x12\x04\x98\x01\x1d\x1e\n\x95\x01\n\x06\x04\x01\x03\0\x02\x04\x12\ + \x04\x9d\x01\x04\x1f\x1a\x84\x01\x20Labels\x20applied\x20to\x20the\x20ce\ + ll\x20by\x20a\n\x20[RowFilter][google.bigtable.v2.RowFilter].\x20\x20Lab\ + els\x20are\x20only\x20set\n\x20on\x20the\x20first\x20CellChunk\x20per\ + \x20cell.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x04\x04\x12\x04\x9d\x01\x04\ + \x0c\n\x0f\n\x07\x04\x01\x03\0\x02\x04\x05\x12\x04\x9d\x01\r\x13\n\x0f\n\ + \x07\x04\x01\x03\0\x02\x04\x01\x12\x04\x9d\x01\x14\x1a\n\x0f\n\x07\x04\ + \x01\x03\0\x02\x04\x03\x12\x04\x9d\x01\x1d\x1e\n\xbf\x02\n\x06\x04\x01\ + \x03\0\x02\x05\x12\x04\xa4\x01\x04\x14\x1a\xae\x02\x20The\x20value\x20st\ + ored\x20in\x20the\x20cell.\x20\x20Cell\x20values\x20can\x20be\x20split\ + \x20across\n\x20multiple\x20CellChunks.\x20\x20In\x20that\x20case\x20onl\ + y\x20the\x20value\x20field\x20will\x20be\n\x20set\x20in\x20CellChunks\ + \x20after\x20the\x20first:\x20the\x20timestamp\x20and\x20labels\n\x20wil\ + l\x20only\x20be\x20present\x20in\x20the\x20first\x20CellChunk,\x20even\ + \x20if\x20the\x20first\n\x20CellChunk\x20came\x20in\x20a\x20previous\x20\ + ReadRowsResponse.\n\n\x11\n\x07\x04\x01\x03\0\x02\x05\x04\x12\x06\xa4\ + \x01\x04\x9d\x01\x1f\n\x0f\n\x07\x04\x01\x03\0\x02\x05\x05\x12\x04\xa4\ + \x01\x04\t\n\x0f\n\x07\x04\x01\x03\0\x02\x05\x01\x12\x04\xa4\x01\n\x0f\n\ + \x0f\n\x07\x04\x01\x03\0\x02\x05\x03\x12\x04\xa4\x01\x12\x13\n\x85\x02\n\ + \x06\x04\x01\x03\0\x02\x06\x12\x04\xaa\x01\x04\x19\x1a\xf4\x01\x20If\x20\ + this\x20CellChunk\x20is\x20part\x20of\x20a\x20chunked\x20cell\x20value\ + \x20and\x20this\x20is\n\x20not\x20the\x20final\x20chunk\x20of\x20that\ + \x20cell,\x20value_size\x20will\x20be\x20set\x20to\x20the\n\x20total\x20\ + length\x20of\x20the\x20cell\x20value.\x20\x20The\x20client\x20can\x20use\ + \x20this\x20size\n\x20to\x20pre-allocate\x20memory\x20to\x20hold\x20the\ + \x20full\x20cell\x20value.\n\n\x11\n\x07\x04\x01\x03\0\x02\x06\x04\x12\ + \x06\xaa\x01\x04\xa4\x01\x14\n\x0f\n\x07\x04\x01\x03\0\x02\x06\x05\x12\ + \x04\xaa\x01\x04\t\n\x0f\n\x07\x04\x01\x03\0\x02\x06\x01\x12\x04\xaa\x01\ + \n\x14\n\x0f\n\x07\x04\x01\x03\0\x02\x06\x03\x12\x04\xaa\x01\x17\x18\n\ + \x10\n\x06\x04\x01\x03\0\x08\0\x12\x06\xac\x01\x04\xb4\x01\x05\n\x0f\n\ + \x07\x04\x01\x03\0\x08\0\x01\x12\x04\xac\x01\n\x14\n\x85\x01\n\x06\x04\ + \x01\x03\0\x02\x07\x12\x04\xaf\x01\x06\x19\x1au\x20Indicates\x20that\x20\ + the\x20client\x20should\x20drop\x20all\x20previous\x20chunks\x20for\n\ + \x20`row_key`,\x20as\x20it\x20will\x20be\x20re-read\x20from\x20the\x20be\ + ginning.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x07\x05\x12\x04\xaf\x01\x06\n\n\ + \x0f\n\x07\x04\x01\x03\0\x02\x07\x01\x12\x04\xaf\x01\x0b\x14\n\x0f\n\x07\ + \x04\x01\x03\0\x02\x07\x03\x12\x04\xaf\x01\x17\x18\n\x83\x01\n\x06\x04\ + \x01\x03\0\x02\x08\x12\x04\xb3\x01\x06\x1a\x1as\x20Indicates\x20that\x20\ + the\x20client\x20can\x20safely\x20process\x20all\x20previous\x20chunks\ + \x20for\n\x20`row_key`,\x20as\x20its\x20data\x20has\x20been\x20fully\x20\ + read.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x08\x05\x12\x04\xb3\x01\x06\n\n\ + \x0f\n\x07\x04\x01\x03\0\x02\x08\x01\x12\x04\xb3\x01\x0b\x15\n\x0f\n\x07\ + \x04\x01\x03\0\x02\x08\x03\x12\x04\xb3\x01\x18\x19\n\x0c\n\x04\x04\x01\ + \x02\0\x12\x04\xb7\x01\x02\x20\n\r\n\x05\x04\x01\x02\0\x04\x12\x04\xb7\ + \x01\x02\n\n\r\n\x05\x04\x01\x02\0\x06\x12\x04\xb7\x01\x0b\x14\n\r\n\x05\ + \x04\x01\x02\0\x01\x12\x04\xb7\x01\x15\x1b\n\r\n\x05\x04\x01\x02\0\x03\ + \x12\x04\xb7\x01\x1e\x1f\n\xc5\x03\n\x04\x04\x01\x02\x01\x12\x04\xc0\x01\ + \x02!\x1a\xb6\x03\x20Optionally\x20the\x20server\x20might\x20return\x20t\ + he\x20row\x20key\x20of\x20the\x20last\x20row\x20it\n\x20has\x20scanned.\ + \x20\x20The\x20client\x20can\x20use\x20this\x20to\x20construct\x20a\x20m\ + ore\n\x20efficient\x20retry\x20request\x20if\x20needed:\x20any\x20row\ + \x20keys\x20or\x20portions\x20of\n\x20ranges\x20less\x20than\x20this\x20\ + row\x20key\x20can\x20be\x20dropped\x20from\x20the\x20request.\n\x20This\ + \x20is\x20primarily\x20useful\x20for\x20cases\x20where\x20the\x20server\ + \x20has\x20read\x20a\n\x20lot\x20of\x20data\x20that\x20was\x20filtered\ + \x20out\x20since\x20the\x20last\x20committed\x20row\n\x20key,\x20allowin\ + g\x20the\x20client\x20to\x20skip\x20that\x20work\x20on\x20a\x20retry.\n\ + \n\x0f\n\x05\x04\x01\x02\x01\x04\x12\x06\xc0\x01\x02\xb7\x01\x20\n\r\n\ + \x05\x04\x01\x02\x01\x05\x12\x04\xc0\x01\x02\x07\n\r\n\x05\x04\x01\x02\ + \x01\x01\x12\x04\xc0\x01\x08\x1c\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\ + \xc0\x01\x1f\x20\n;\n\x02\x04\x02\x12\x06\xc4\x01\0\xcd\x01\x01\x1a-\x20\ + Request\x20message\x20for\x20Bigtable.SampleRowKeys.\n\n\x0b\n\x03\x04\ + \x02\x01\x12\x04\xc4\x01\x08\x1c\n\x9f\x01\n\x04\x04\x02\x02\0\x12\x04\ + \xc8\x01\x02\x18\x1a\x90\x01\x20The\x20unique\x20name\x20of\x20the\x20ta\ + ble\x20from\x20which\x20to\x20sample\x20row\x20keys.\n\x20Values\x20are\ + \x20of\x20the\x20form\n\x20`projects//instances//tabl\ + es/
`.\n\n\x0f\n\x05\x04\x02\x02\0\x04\x12\x06\xc8\x01\x02\xc4\x01\ + \x1e\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\xc8\x01\x02\x08\n\r\n\x05\x04\ + \x02\x02\0\x01\x12\x04\xc8\x01\t\x13\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\ + \xc8\x01\x16\x17\n\x80\x01\n\x04\x04\x02\x02\x01\x12\x04\xcc\x01\x02\x1c\ + \x1ar\x20This\x20value\x20specifies\x20routing\x20for\x20replication.\ + \x20If\x20not\x20specified,\x20the\n\x20\"default\"\x20application\x20pr\ + ofile\x20will\x20be\x20used.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\x06\ + \xcc\x01\x02\xc8\x01\x18\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xcc\x01\ + \x02\x08\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xcc\x01\t\x17\n\r\n\x05\ + \x04\x02\x02\x01\x03\x12\x04\xcc\x01\x1a\x1b\n<\n\x02\x04\x03\x12\x06\ + \xd0\x01\0\xdf\x01\x01\x1a.\x20Response\x20message\x20for\x20Bigtable.Sa\ + mpleRowKeys.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xd0\x01\x08\x1d\n\xe0\x03\ + \n\x04\x04\x03\x02\0\x12\x04\xd8\x01\x02\x14\x1a\xd1\x03\x20Sorted\x20st\ + reamed\x20sequence\x20of\x20sample\x20row\x20keys\x20in\x20the\x20table.\ + \x20The\x20table\x20might\n\x20have\x20contents\x20before\x20the\x20firs\ + t\x20row\x20key\x20in\x20the\x20list\x20and\x20after\x20the\x20last\x20o\ + ne,\n\x20but\x20a\x20key\x20containing\x20the\x20empty\x20string\x20indi\ + cates\x20\"end\x20of\x20table\"\x20and\x20will\x20be\n\x20the\x20last\ + \x20response\x20given,\x20if\x20present.\n\x20Note\x20that\x20row\x20key\ + s\x20in\x20this\x20list\x20may\x20not\x20have\x20ever\x20been\x20written\ + \x20to\x20or\x20read\n\x20from,\x20and\x20users\x20should\x20therefore\ + \x20not\x20make\x20any\x20assumptions\x20about\x20the\x20row\x20key\n\ + \x20structure\x20that\x20are\x20specific\x20to\x20their\x20use\x20case.\ + \n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xd8\x01\x02\xd0\x01\x1f\n\r\n\ + \x05\x04\x03\x02\0\x05\x12\x04\xd8\x01\x02\x07\n\r\n\x05\x04\x03\x02\0\ + \x01\x12\x04\xd8\x01\x08\x0f\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xd8\x01\ + \x12\x13\n\x80\x02\n\x04\x04\x03\x02\x01\x12\x04\xde\x01\x02\x19\x1a\xf1\ + \x01\x20Approximate\x20total\x20storage\x20space\x20used\x20by\x20all\ + \x20rows\x20in\x20the\x20table\x20which\x20precede\n\x20`row_key`.\x20Bu\ + ffering\x20the\x20contents\x20of\x20all\x20rows\x20between\x20two\x20sub\ + sequent\n\x20samples\x20would\x20require\x20space\x20roughly\x20equal\ + \x20to\x20the\x20difference\x20in\x20their\n\x20`offset_bytes`\x20fields\ + .\n\n\x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\xde\x01\x02\xd8\x01\x14\n\r\ + \n\x05\x04\x03\x02\x01\x05\x12\x04\xde\x01\x02\x07\n\r\n\x05\x04\x03\x02\ + \x01\x01\x12\x04\xde\x01\x08\x14\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\ + \xde\x01\x17\x18\n7\n\x02\x04\x04\x12\x06\xe2\x01\0\xf3\x01\x01\x1a)\x20\ + Request\x20message\x20for\x20Bigtable.MutateRow.\n\n\x0b\n\x03\x04\x04\ + \x01\x12\x04\xe2\x01\x08\x18\n\xa9\x01\n\x04\x04\x04\x02\0\x12\x04\xe6\ + \x01\x02\x18\x1a\x9a\x01\x20The\x20unique\x20name\x20of\x20the\x20table\ + \x20to\x20which\x20the\x20mutation\x20should\x20be\x20applied.\n\x20Valu\ + es\x20are\x20of\x20the\x20form\n\x20`projects//instances//tables/
`.\n\n\x0f\n\x05\x04\x04\x02\0\x04\x12\x06\xe6\x01\ + \x02\xe2\x01\x1a\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\xe6\x01\x02\x08\n\r\ + \n\x05\x04\x04\x02\0\x01\x12\x04\xe6\x01\t\x13\n\r\n\x05\x04\x04\x02\0\ + \x03\x12\x04\xe6\x01\x16\x17\n\x80\x01\n\x04\x04\x04\x02\x01\x12\x04\xea\ + \x01\x02\x1c\x1ar\x20This\x20value\x20specifies\x20routing\x20for\x20rep\ + lication.\x20If\x20not\x20specified,\x20the\n\x20\"default\"\x20applicat\ + ion\x20profile\x20will\x20be\x20used.\n\n\x0f\n\x05\x04\x04\x02\x01\x04\ + \x12\x06\xea\x01\x02\xe6\x01\x18\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\ + \xea\x01\x02\x08\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xea\x01\t\x17\n\r\ + \n\x05\x04\x04\x02\x01\x03\x12\x04\xea\x01\x1a\x1b\nK\n\x04\x04\x04\x02\ + \x02\x12\x04\xed\x01\x02\x14\x1a=\x20The\x20key\x20of\x20the\x20row\x20t\ + o\x20which\x20the\x20mutation\x20should\x20be\x20applied.\n\n\x0f\n\x05\ + \x04\x04\x02\x02\x04\x12\x06\xed\x01\x02\xea\x01\x1c\n\r\n\x05\x04\x04\ + \x02\x02\x05\x12\x04\xed\x01\x02\x07\n\r\n\x05\x04\x04\x02\x02\x01\x12\ + \x04\xed\x01\x08\x0f\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\xed\x01\x12\ + \x13\n\xd7\x01\n\x04\x04\x04\x02\x03\x12\x04\xf2\x01\x02\"\x1a\xc8\x01\ + \x20Changes\x20to\x20be\x20atomically\x20applied\x20to\x20the\x20specifi\ + ed\x20row.\x20Entries\x20are\x20applied\n\x20in\x20order,\x20meaning\x20\ + that\x20earlier\x20mutations\x20can\x20be\x20masked\x20by\x20later\x20on\ + es.\n\x20Must\x20contain\x20at\x20least\x20one\x20entry\x20and\x20at\x20\ + most\x20100000.\n\n\r\n\x05\x04\x04\x02\x03\x04\x12\x04\xf2\x01\x02\n\n\ + \r\n\x05\x04\x04\x02\x03\x06\x12\x04\xf2\x01\x0b\x13\n\r\n\x05\x04\x04\ + \x02\x03\x01\x12\x04\xf2\x01\x14\x1d\n\r\n\x05\x04\x04\x02\x03\x03\x12\ + \x04\xf2\x01\x20!\n8\n\x02\x04\x05\x12\x06\xf6\x01\0\xf8\x01\x01\x1a*\ + \x20Response\x20message\x20for\x20Bigtable.MutateRow.\n\n\x0b\n\x03\x04\ + \x05\x01\x12\x04\xf6\x01\x08\x19\n?\n\x02\x04\x06\x12\x06\xfb\x01\0\x94\ + \x02\x01\x1a1\x20Request\x20message\x20for\x20BigtableService.MutateRows\ + .\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xfb\x01\x08\x19\n\x0e\n\x04\x04\x06\ + \x03\0\x12\x06\xfc\x01\x02\x85\x02\x03\n\r\n\x05\x04\x06\x03\0\x01\x12\ + \x04\xfc\x01\n\x0f\nP\n\x06\x04\x06\x03\0\x02\0\x12\x04\xfe\x01\x04\x16\ + \x1a@\x20The\x20key\x20of\x20the\x20row\x20to\x20which\x20the\x20`mutati\ + ons`\x20should\x20be\x20applied.\n\n\x11\n\x07\x04\x06\x03\0\x02\0\x04\ + \x12\x06\xfe\x01\x04\xfc\x01\x11\n\x0f\n\x07\x04\x06\x03\0\x02\0\x05\x12\ + \x04\xfe\x01\x04\t\n\x0f\n\x07\x04\x06\x03\0\x02\0\x01\x12\x04\xfe\x01\n\ + \x11\n\x0f\n\x07\x04\x06\x03\0\x02\0\x03\x12\x04\xfe\x01\x14\x15\n\xd0\ + \x01\n\x06\x04\x06\x03\0\x02\x01\x12\x04\x84\x02\x04$\x1a\xbf\x01\x20Cha\ + nges\x20to\x20be\x20atomically\x20applied\x20to\x20the\x20specified\x20r\ + ow.\x20Mutations\x20are\n\x20applied\x20in\x20order,\x20meaning\x20that\ + \x20earlier\x20mutations\x20can\x20be\x20masked\x20by\n\x20later\x20ones\ + .\n\x20You\x20must\x20specify\x20at\x20least\x20one\x20mutation.\n\n\x0f\ + \n\x07\x04\x06\x03\0\x02\x01\x04\x12\x04\x84\x02\x04\x0c\n\x0f\n\x07\x04\ + \x06\x03\0\x02\x01\x06\x12\x04\x84\x02\r\x15\n\x0f\n\x07\x04\x06\x03\0\ + \x02\x01\x01\x12\x04\x84\x02\x16\x1f\n\x0f\n\x07\x04\x06\x03\0\x02\x01\ + \x03\x12\x04\x84\x02\"#\nV\n\x04\x04\x06\x02\0\x12\x04\x88\x02\x02\x18\ + \x1aH\x20The\x20unique\x20name\x20of\x20the\x20table\x20to\x20which\x20t\ + he\x20mutations\x20should\x20be\x20applied.\n\n\x0f\n\x05\x04\x06\x02\0\ + \x04\x12\x06\x88\x02\x02\x85\x02\x03\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\ + \x88\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\x88\x02\t\x13\n\r\n\ + \x05\x04\x06\x02\0\x03\x12\x04\x88\x02\x16\x17\n\x80\x01\n\x04\x04\x06\ + \x02\x01\x12\x04\x8c\x02\x02\x1c\x1ar\x20This\x20value\x20specifies\x20r\ + outing\x20for\x20replication.\x20If\x20not\x20specified,\x20the\n\x20\"d\ + efault\"\x20application\x20profile\x20will\x20be\x20used.\n\n\x0f\n\x05\ + \x04\x06\x02\x01\x04\x12\x06\x8c\x02\x02\x88\x02\x18\n\r\n\x05\x04\x06\ + \x02\x01\x05\x12\x04\x8c\x02\x02\x08\n\r\n\x05\x04\x06\x02\x01\x01\x12\ + \x04\x8c\x02\t\x17\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\x8c\x02\x1a\x1b\ + \n\xc1\x02\n\x04\x04\x06\x02\x02\x12\x04\x93\x02\x02\x1d\x1a\xb2\x02\x20\ + The\x20row\x20keys\x20and\x20corresponding\x20mutations\x20to\x20be\x20a\ + pplied\x20in\x20bulk.\n\x20Each\x20entry\x20is\x20applied\x20as\x20an\ + \x20atomic\x20mutation,\x20but\x20the\x20entries\x20may\x20be\n\x20appli\ + ed\x20in\x20arbitrary\x20order\x20(even\x20between\x20entries\x20for\x20\ + the\x20same\x20row).\n\x20At\x20least\x20one\x20entry\x20must\x20be\x20s\ + pecified,\x20and\x20in\x20total\x20the\x20entries\x20can\n\x20contain\ + \x20at\x20most\x20100000\x20mutations.\n\n\r\n\x05\x04\x06\x02\x02\x04\ + \x12\x04\x93\x02\x02\n\n\r\n\x05\x04\x06\x02\x02\x06\x12\x04\x93\x02\x0b\ + \x10\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\x93\x02\x11\x18\n\r\n\x05\x04\ + \x06\x02\x02\x03\x12\x04\x93\x02\x1b\x1c\n@\n\x02\x04\x07\x12\x06\x97\ + \x02\0\xa6\x02\x01\x1a2\x20Response\x20message\x20for\x20BigtableService\ + .MutateRows.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\x97\x02\x08\x1a\n\x0e\n\ + \x04\x04\x07\x03\0\x12\x06\x98\x02\x02\xa2\x02\x03\n\r\n\x05\x04\x07\x03\ + \0\x01\x12\x04\x98\x02\n\x0f\nz\n\x06\x04\x07\x03\0\x02\0\x12\x04\x9b\ + \x02\x04\x14\x1aj\x20The\x20index\x20into\x20the\x20original\x20request'\ + s\x20`entries`\x20list\x20of\x20the\x20Entry\n\x20for\x20which\x20a\x20r\ + esult\x20is\x20being\x20reported.\n\n\x11\n\x07\x04\x07\x03\0\x02\0\x04\ + \x12\x06\x9b\x02\x04\x98\x02\x11\n\x0f\n\x07\x04\x07\x03\0\x02\0\x05\x12\ + \x04\x9b\x02\x04\t\n\x0f\n\x07\x04\x07\x03\0\x02\0\x01\x12\x04\x9b\x02\n\ + \x0f\n\x0f\n\x07\x04\x07\x03\0\x02\0\x03\x12\x04\x9b\x02\x12\x13\n\x9e\ + \x02\n\x06\x04\x07\x03\0\x02\x01\x12\x04\xa1\x02\x04!\x1a\x8d\x02\x20The\ + \x20result\x20of\x20the\x20request\x20Entry\x20identified\x20by\x20`inde\ + x`.\n\x20Depending\x20on\x20how\x20requests\x20are\x20batched\x20during\ + \x20execution,\x20it\x20is\x20possible\n\x20for\x20one\x20Entry\x20to\ + \x20fail\x20due\x20to\x20an\x20error\x20with\x20another\x20Entry.\x20In\ + \x20the\x20event\n\x20that\x20this\x20occurs,\x20the\x20same\x20error\ + \x20will\x20be\x20reported\x20for\x20both\x20entries.\n\n\x11\n\x07\x04\ + \x07\x03\0\x02\x01\x04\x12\x06\xa1\x02\x04\x9b\x02\x14\n\x0f\n\x07\x04\ + \x07\x03\0\x02\x01\x06\x12\x04\xa1\x02\x04\x15\n\x0f\n\x07\x04\x07\x03\0\ + \x02\x01\x01\x12\x04\xa1\x02\x16\x1c\n\x0f\n\x07\x04\x07\x03\0\x02\x01\ + \x03\x12\x04\xa1\x02\x1f\x20\nG\n\x04\x04\x07\x02\0\x12\x04\xa5\x02\x02\ + \x1d\x1a9\x20One\x20or\x20more\x20results\x20for\x20Entries\x20from\x20t\ + he\x20batch\x20request.\n\n\r\n\x05\x04\x07\x02\0\x04\x12\x04\xa5\x02\ + \x02\n\n\r\n\x05\x04\x07\x02\0\x06\x12\x04\xa5\x02\x0b\x10\n\r\n\x05\x04\ + \x07\x02\0\x01\x12\x04\xa5\x02\x11\x18\n\r\n\x05\x04\x07\x02\0\x03\x12\ + \x04\xa5\x02\x1b\x1c\n?\n\x02\x04\x08\x12\x06\xa9\x02\0\xca\x02\x01\x1a1\ + \x20Request\x20message\x20for\x20Bigtable.CheckAndMutateRow.\n\n\x0b\n\ + \x03\x04\x08\x01\x12\x04\xa9\x02\x08\x20\n\xb6\x01\n\x04\x04\x08\x02\0\ + \x12\x04\xae\x02\x02\x18\x1a\xa7\x01\x20The\x20unique\x20name\x20of\x20t\ + he\x20table\x20to\x20which\x20the\x20conditional\x20mutation\x20should\ + \x20be\n\x20applied.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`proje\ + cts//instances//tables/
`.\n\n\x0f\n\x05\x04\ + \x08\x02\0\x04\x12\x06\xae\x02\x02\xa9\x02\"\n\r\n\x05\x04\x08\x02\0\x05\ + \x12\x04\xae\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xae\x02\t\ + \x13\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xae\x02\x16\x17\n\x80\x01\n\x04\ + \x04\x08\x02\x01\x12\x04\xb2\x02\x02\x1c\x1ar\x20This\x20value\x20specif\ + ies\x20routing\x20for\x20replication.\x20If\x20not\x20specified,\x20the\ + \n\x20\"default\"\x20application\x20profile\x20will\x20be\x20used.\n\n\ + \x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\xb2\x02\x02\xae\x02\x18\n\r\n\x05\ + \x04\x08\x02\x01\x05\x12\x04\xb2\x02\x02\x08\n\r\n\x05\x04\x08\x02\x01\ + \x01\x12\x04\xb2\x02\t\x17\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xb2\x02\ + \x1a\x1b\nW\n\x04\x04\x08\x02\x02\x12\x04\xb5\x02\x02\x14\x1aI\x20The\ + \x20key\x20of\x20the\x20row\x20to\x20which\x20the\x20conditional\x20muta\ + tion\x20should\x20be\x20applied.\n\n\x0f\n\x05\x04\x08\x02\x02\x04\x12\ + \x06\xb5\x02\x02\xb2\x02\x1c\n\r\n\x05\x04\x08\x02\x02\x05\x12\x04\xb5\ + \x02\x02\x07\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\xb5\x02\x08\x0f\n\r\n\ + \x05\x04\x08\x02\x02\x03\x12\x04\xb5\x02\x12\x13\n\x80\x02\n\x04\x04\x08\ + \x02\x03\x12\x04\xbb\x02\x02!\x1a\xf1\x01\x20The\x20filter\x20to\x20be\ + \x20applied\x20to\x20the\x20contents\x20of\x20the\x20specified\x20row.\ + \x20Depending\n\x20on\x20whether\x20or\x20not\x20any\x20results\x20are\ + \x20yielded,\x20either\x20`true_mutations`\x20or\n\x20`false_mutations`\ + \x20will\x20be\x20executed.\x20If\x20unset,\x20checks\x20that\x20the\x20\ + row\x20contains\n\x20any\x20values\x20at\x20all.\n\n\x0f\n\x05\x04\x08\ + \x02\x03\x04\x12\x06\xbb\x02\x02\xb5\x02\x14\n\r\n\x05\x04\x08\x02\x03\ + \x06\x12\x04\xbb\x02\x02\x0b\n\r\n\x05\x04\x08\x02\x03\x01\x12\x04\xbb\ + \x02\x0c\x1c\n\r\n\x05\x04\x08\x02\x03\x03\x12\x04\xbb\x02\x1f\x20\n\xc1\ + \x02\n\x04\x04\x08\x02\x04\x12\x04\xc2\x02\x02'\x1a\xb2\x02\x20Changes\ + \x20to\x20be\x20atomically\x20applied\x20to\x20the\x20specified\x20row\ + \x20if\x20`predicate_filter`\n\x20yields\x20at\x20least\x20one\x20cell\ + \x20when\x20applied\x20to\x20`row_key`.\x20Entries\x20are\x20applied\x20\ + in\n\x20order,\x20meaning\x20that\x20earlier\x20mutations\x20can\x20be\ + \x20masked\x20by\x20later\x20ones.\n\x20Must\x20contain\x20at\x20least\ + \x20one\x20entry\x20if\x20`false_mutations`\x20is\x20empty,\x20and\x20at\ + \x20most\n\x20100000.\n\n\r\n\x05\x04\x08\x02\x04\x04\x12\x04\xc2\x02\ + \x02\n\n\r\n\x05\x04\x08\x02\x04\x06\x12\x04\xc2\x02\x0b\x13\n\r\n\x05\ + \x04\x08\x02\x04\x01\x12\x04\xc2\x02\x14\"\n\r\n\x05\x04\x08\x02\x04\x03\ + \x12\x04\xc2\x02%&\n\xc0\x02\n\x04\x04\x08\x02\x05\x12\x04\xc9\x02\x02(\ + \x1a\xb1\x02\x20Changes\x20to\x20be\x20atomically\x20applied\x20to\x20th\ + e\x20specified\x20row\x20if\x20`predicate_filter`\n\x20does\x20not\x20yi\ + eld\x20any\x20cells\x20when\x20applied\x20to\x20`row_key`.\x20Entries\ + \x20are\x20applied\x20in\n\x20order,\x20meaning\x20that\x20earlier\x20mu\ + tations\x20can\x20be\x20masked\x20by\x20later\x20ones.\n\x20Must\x20cont\ + ain\x20at\x20least\x20one\x20entry\x20if\x20`true_mutations`\x20is\x20em\ + pty,\x20and\x20at\x20most\n\x20100000.\n\n\r\n\x05\x04\x08\x02\x05\x04\ + \x12\x04\xc9\x02\x02\n\n\r\n\x05\x04\x08\x02\x05\x06\x12\x04\xc9\x02\x0b\ + \x13\n\r\n\x05\x04\x08\x02\x05\x01\x12\x04\xc9\x02\x14#\n\r\n\x05\x04\ + \x08\x02\x05\x03\x12\x04\xc9\x02&'\n@\n\x02\x04\t\x12\x06\xcd\x02\0\xd1\ + \x02\x01\x1a2\x20Response\x20message\x20for\x20Bigtable.CheckAndMutateRo\ + w.\n\n\x0b\n\x03\x04\t\x01\x12\x04\xcd\x02\x08!\nk\n\x04\x04\t\x02\0\x12\ + \x04\xd0\x02\x02\x1d\x1a]\x20Whether\x20or\x20not\x20the\x20request's\ + \x20`predicate_filter`\x20yielded\x20any\x20results\x20for\n\x20the\x20s\ + pecified\x20row.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\x06\xd0\x02\x02\xcd\ + \x02#\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xd0\x02\x02\x06\n\r\n\x05\x04\t\ + \x02\0\x01\x12\x04\xd0\x02\x07\x18\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xd0\ + \x02\x1b\x1c\n@\n\x02\x04\n\x12\x06\xd4\x02\0\xe6\x02\x01\x1a2\x20Reques\ + t\x20message\x20for\x20Bigtable.ReadModifyWriteRow.\n\n\x0b\n\x03\x04\n\ + \x01\x12\x04\xd4\x02\x08!\n\xb9\x01\n\x04\x04\n\x02\0\x12\x04\xd9\x02\ + \x02\x18\x1a\xaa\x01\x20The\x20unique\x20name\x20of\x20the\x20table\x20t\ + o\x20which\x20the\x20read/modify/write\x20rules\x20should\x20be\n\x20app\ + lied.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects//i\ + nstances//tables/
`.\n\n\x0f\n\x05\x04\n\x02\0\x04\x12\ + \x06\xd9\x02\x02\xd4\x02#\n\r\n\x05\x04\n\x02\0\x05\x12\x04\xd9\x02\x02\ + \x08\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xd9\x02\t\x13\n\r\n\x05\x04\n\x02\ + \0\x03\x12\x04\xd9\x02\x16\x17\n\x80\x01\n\x04\x04\n\x02\x01\x12\x04\xdd\ + \x02\x02\x1c\x1ar\x20This\x20value\x20specifies\x20routing\x20for\x20rep\ + lication.\x20If\x20not\x20specified,\x20the\n\x20\"default\"\x20applicat\ + ion\x20profile\x20will\x20be\x20used.\n\n\x0f\n\x05\x04\n\x02\x01\x04\ + \x12\x06\xdd\x02\x02\xd9\x02\x18\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\xdd\ + \x02\x02\x08\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\xdd\x02\t\x17\n\r\n\x05\ + \x04\n\x02\x01\x03\x12\x04\xdd\x02\x1a\x1b\nZ\n\x04\x04\n\x02\x02\x12\ + \x04\xe0\x02\x02\x14\x1aL\x20The\x20key\x20of\x20the\x20row\x20to\x20whi\ + ch\x20the\x20read/modify/write\x20rules\x20should\x20be\x20applied.\n\n\ + \x0f\n\x05\x04\n\x02\x02\x04\x12\x06\xe0\x02\x02\xdd\x02\x1c\n\r\n\x05\ + \x04\n\x02\x02\x05\x12\x04\xe0\x02\x02\x07\n\r\n\x05\x04\n\x02\x02\x01\ + \x12\x04\xe0\x02\x08\x0f\n\r\n\x05\x04\n\x02\x02\x03\x12\x04\xe0\x02\x12\ + \x13\n\xc7\x01\n\x04\x04\n\x02\x03\x12\x04\xe5\x02\x02)\x1a\xb8\x01\x20R\ + ules\x20specifying\x20how\x20the\x20specified\x20row's\x20contents\x20ar\ + e\x20to\x20be\x20transformed\n\x20into\x20writes.\x20Entries\x20are\x20a\ + pplied\x20in\x20order,\x20meaning\x20that\x20earlier\x20rules\x20will\n\ + \x20affect\x20the\x20results\x20of\x20later\x20ones.\n\n\r\n\x05\x04\n\ + \x02\x03\x04\x12\x04\xe5\x02\x02\n\n\r\n\x05\x04\n\x02\x03\x06\x12\x04\ + \xe5\x02\x0b\x1e\n\r\n\x05\x04\n\x02\x03\x01\x12\x04\xe5\x02\x1f$\n\r\n\ + \x05\x04\n\x02\x03\x03\x12\x04\xe5\x02'(\nA\n\x02\x04\x0b\x12\x06\xe9\ + \x02\0\xec\x02\x01\x1a3\x20Response\x20message\x20for\x20Bigtable.ReadMo\ + difyWriteRow.\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\xe9\x02\x08\"\nW\n\x04\ + \x04\x0b\x02\0\x12\x04\xeb\x02\x02\x0e\x1aI\x20A\x20Row\x20containing\ + \x20the\x20new\x20contents\x20of\x20all\x20cells\x20modified\x20by\x20th\ + e\x20request.\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\xeb\x02\x02\xe9\ + \x02$\n\r\n\x05\x04\x0b\x02\0\x06\x12\x04\xeb\x02\x02\x05\n\r\n\x05\x04\ + \x0b\x02\0\x01\x12\x04\xeb\x02\x06\t\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\ + \xeb\x02\x0c\rb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable_grpc.rs new file mode 100644 index 00000000..0d3d9280 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/bigtable_grpc.rs @@ -0,0 +1,187 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_BIGTABLE_READ_ROWS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.bigtable.v2.Bigtable/ReadRows", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_SAMPLE_ROW_KEYS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.bigtable.v2.Bigtable/SampleRowKeys", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_MUTATE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v2.Bigtable/MutateRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_MUTATE_ROWS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.bigtable.v2.Bigtable/MutateRows", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_CHECK_AND_MUTATE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v2.Bigtable/CheckAndMutateRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_BIGTABLE_READ_MODIFY_WRITE_ROW: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.bigtable.v2.Bigtable/ReadModifyWriteRow", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct BigtableClient { + client: ::grpcio::Client, +} + +impl BigtableClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + BigtableClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn read_rows_opt(&self, req: &super::bigtable::ReadRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_BIGTABLE_READ_ROWS, req, opt) + } + + pub fn read_rows(&self, req: &super::bigtable::ReadRowsRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.read_rows_opt(req, ::grpcio::CallOption::default()) + } + + pub fn sample_row_keys_opt(&self, req: &super::bigtable::SampleRowKeysRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_BIGTABLE_SAMPLE_ROW_KEYS, req, opt) + } + + pub fn sample_row_keys(&self, req: &super::bigtable::SampleRowKeysRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.sample_row_keys_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_row_opt(&self, req: &super::bigtable::MutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_MUTATE_ROW, req, opt) + } + + pub fn mutate_row(&self, req: &super::bigtable::MutateRowRequest) -> ::grpcio::Result { + self.mutate_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_row_async_opt(&self, req: &super::bigtable::MutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_MUTATE_ROW, req, opt) + } + + pub fn mutate_row_async(&self, req: &super::bigtable::MutateRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.mutate_row_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn mutate_rows_opt(&self, req: &super::bigtable::MutateRowsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_BIGTABLE_MUTATE_ROWS, req, opt) + } + + pub fn mutate_rows(&self, req: &super::bigtable::MutateRowsRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.mutate_rows_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_and_mutate_row_opt(&self, req: &super::bigtable::CheckAndMutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_CHECK_AND_MUTATE_ROW, req, opt) + } + + pub fn check_and_mutate_row(&self, req: &super::bigtable::CheckAndMutateRowRequest) -> ::grpcio::Result { + self.check_and_mutate_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn check_and_mutate_row_async_opt(&self, req: &super::bigtable::CheckAndMutateRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_CHECK_AND_MUTATE_ROW, req, opt) + } + + pub fn check_and_mutate_row_async(&self, req: &super::bigtable::CheckAndMutateRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.check_and_mutate_row_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_modify_write_row_opt(&self, req: &super::bigtable::ReadModifyWriteRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_BIGTABLE_READ_MODIFY_WRITE_ROW, req, opt) + } + + pub fn read_modify_write_row(&self, req: &super::bigtable::ReadModifyWriteRowRequest) -> ::grpcio::Result { + self.read_modify_write_row_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_modify_write_row_async_opt(&self, req: &super::bigtable::ReadModifyWriteRowRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_BIGTABLE_READ_MODIFY_WRITE_ROW, req, opt) + } + + pub fn read_modify_write_row_async(&self, req: &super::bigtable::ReadModifyWriteRowRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.read_modify_write_row_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Bigtable { + fn read_rows(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::ReadRowsRequest, sink: ::grpcio::ServerStreamingSink); + fn sample_row_keys(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::SampleRowKeysRequest, sink: ::grpcio::ServerStreamingSink); + fn mutate_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::MutateRowRequest, sink: ::grpcio::UnarySink); + fn mutate_rows(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::MutateRowsRequest, sink: ::grpcio::ServerStreamingSink); + fn check_and_mutate_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::CheckAndMutateRowRequest, sink: ::grpcio::UnarySink); + fn read_modify_write_row(&mut self, ctx: ::grpcio::RpcContext, req: super::bigtable::ReadModifyWriteRowRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_bigtable(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_BIGTABLE_READ_ROWS, move |ctx, req, resp| { + instance.read_rows(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_BIGTABLE_SAMPLE_ROW_KEYS, move |ctx, req, resp| { + instance.sample_row_keys(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_MUTATE_ROW, move |ctx, req, resp| { + instance.mutate_row(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_BIGTABLE_MUTATE_ROWS, move |ctx, req, resp| { + instance.mutate_rows(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_CHECK_AND_MUTATE_ROW, move |ctx, req, resp| { + instance.check_and_mutate_row(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_BIGTABLE_READ_MODIFY_WRITE_ROW, move |ctx, req, resp| { + instance.read_modify_write_row(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/data.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/data.rs new file mode 100644 index 00000000..3f63831d --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/data.rs @@ -0,0 +1,7037 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/bigtable/v2/data.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Row { + // message fields + pub key: ::std::vec::Vec, + pub families: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Row { + fn default() -> &'a Row { + ::default_instance() + } +} + +impl Row { + pub fn new() -> Row { + ::std::default::Default::default() + } + + // bytes key = 1; + + + pub fn get_key(&self) -> &[u8] { + &self.key + } + pub fn clear_key(&mut self) { + self.key.clear(); + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::vec::Vec) { + self.key = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::vec::Vec { + &mut self.key + } + + // Take field + pub fn take_key(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.key, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v2.Family families = 2; + + + pub fn get_families(&self) -> &[Family] { + &self.families + } + pub fn clear_families(&mut self) { + self.families.clear(); + } + + // Param is passed by value, moved + pub fn set_families(&mut self, v: ::protobuf::RepeatedField) { + self.families = v; + } + + // Mutable pointer to the field. + pub fn mut_families(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.families + } + + // Take field + pub fn take_families(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.families, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Row { + fn is_initialized(&self) -> bool { + for v in &self.families { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.families)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.key.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.key); + } + for value in &self.families { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.key.is_empty() { + os.write_bytes(1, &self.key)?; + } + for v in &self.families { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Row { + Row::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "key", + |m: &Row| { &m.key }, + |m: &mut Row| { &mut m.key }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "families", + |m: &Row| { &m.families }, + |m: &mut Row| { &mut m.families }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Row", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Row { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Row, + }; + unsafe { + instance.get(Row::new) + } + } +} + +impl ::protobuf::Clear for Row { + fn clear(&mut self) { + self.key.clear(); + self.families.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Row { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Row { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Family { + // message fields + pub name: ::std::string::String, + pub columns: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Family { + fn default() -> &'a Family { + ::default_instance() + } +} + +impl Family { + pub fn new() -> Family { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.bigtable.v2.Column columns = 2; + + + pub fn get_columns(&self) -> &[Column] { + &self.columns + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + + // Param is passed by value, moved + pub fn set_columns(&mut self, v: ::protobuf::RepeatedField) { + self.columns = v; + } + + // Mutable pointer to the field. + pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.columns + } + + // Take field + pub fn take_columns(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Family { + fn is_initialized(&self) -> bool { + for v in &self.columns { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.columns)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.columns { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.columns { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Family { + Family::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Family| { &m.name }, + |m: &mut Family| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "columns", + |m: &Family| { &m.columns }, + |m: &mut Family| { &mut m.columns }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Family", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Family { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Family, + }; + unsafe { + instance.get(Family::new) + } + } +} + +impl ::protobuf::Clear for Family { + fn clear(&mut self) { + self.name.clear(); + self.columns.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Family { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Family { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Column { + // message fields + pub qualifier: ::std::vec::Vec, + pub cells: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Column { + fn default() -> &'a Column { + ::default_instance() + } +} + +impl Column { + pub fn new() -> Column { + ::std::default::Default::default() + } + + // bytes qualifier = 1; + + + pub fn get_qualifier(&self) -> &[u8] { + &self.qualifier + } + pub fn clear_qualifier(&mut self) { + self.qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_qualifier(&mut self, v: ::std::vec::Vec) { + self.qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.qualifier + } + + // Take field + pub fn take_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.qualifier, ::std::vec::Vec::new()) + } + + // repeated .google.bigtable.v2.Cell cells = 2; + + + pub fn get_cells(&self) -> &[Cell] { + &self.cells + } + pub fn clear_cells(&mut self) { + self.cells.clear(); + } + + // Param is passed by value, moved + pub fn set_cells(&mut self, v: ::protobuf::RepeatedField) { + self.cells = v; + } + + // Mutable pointer to the field. + pub fn mut_cells(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.cells + } + + // Take field + pub fn take_cells(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.cells, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Column { + fn is_initialized(&self) -> bool { + for v in &self.cells { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.qualifier)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.cells)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.qualifier); + } + for value in &self.cells { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.qualifier.is_empty() { + os.write_bytes(1, &self.qualifier)?; + } + for v in &self.cells { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Column { + Column::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "qualifier", + |m: &Column| { &m.qualifier }, + |m: &mut Column| { &mut m.qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "cells", + |m: &Column| { &m.cells }, + |m: &mut Column| { &mut m.cells }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Column", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Column { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Column, + }; + unsafe { + instance.get(Column::new) + } + } +} + +impl ::protobuf::Clear for Column { + fn clear(&mut self) { + self.qualifier.clear(); + self.cells.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Column { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Column { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Cell { + // message fields + pub timestamp_micros: i64, + pub value: ::std::vec::Vec, + pub labels: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Cell { + fn default() -> &'a Cell { + ::default_instance() + } +} + +impl Cell { + pub fn new() -> Cell { + ::std::default::Default::default() + } + + // int64 timestamp_micros = 1; + + + pub fn get_timestamp_micros(&self) -> i64 { + self.timestamp_micros + } + pub fn clear_timestamp_micros(&mut self) { + self.timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_timestamp_micros(&mut self, v: i64) { + self.timestamp_micros = v; + } + + // bytes value = 2; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } + + // repeated string labels = 3; + + + pub fn get_labels(&self) -> &[::std::string::String] { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Cell { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.timestamp_micros = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(1, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.value); + } + for value in &self.labels { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.timestamp_micros != 0 { + os.write_int64(1, self.timestamp_micros)?; + } + if !self.value.is_empty() { + os.write_bytes(2, &self.value)?; + } + for v in &self.labels { + os.write_string(3, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Cell { + Cell::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "timestamp_micros", + |m: &Cell| { &m.timestamp_micros }, + |m: &mut Cell| { &mut m.timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &Cell| { &m.value }, + |m: &mut Cell| { &mut m.value }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Cell| { &m.labels }, + |m: &mut Cell| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Cell", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Cell { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Cell, + }; + unsafe { + instance.get(Cell::new) + } + } +} + +impl ::protobuf::Clear for Cell { + fn clear(&mut self) { + self.timestamp_micros = 0; + self.value.clear(); + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Cell { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Cell { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowRange { + // message oneof groups + pub start_key: ::std::option::Option, + pub end_key: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowRange { + fn default() -> &'a RowRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum RowRange_oneof_start_key { + start_key_closed(::std::vec::Vec), + start_key_open(::std::vec::Vec), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum RowRange_oneof_end_key { + end_key_open(::std::vec::Vec), + end_key_closed(::std::vec::Vec), +} + +impl RowRange { + pub fn new() -> RowRange { + ::std::default::Default::default() + } + + // bytes start_key_closed = 1; + + + pub fn get_start_key_closed(&self) -> &[u8] { + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_key_closed(&mut self) { + self.start_key = ::std::option::Option::None; + } + + pub fn has_start_key_closed(&self) -> bool { + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_key_closed(&mut self, v: ::std::vec::Vec) { + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_key_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(_)) = self.start_key { + } else { + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(::std::vec::Vec::new())); + } + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_key_closed(&mut self) -> ::std::vec::Vec { + if self.has_start_key_closed() { + match self.start_key.take() { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes start_key_open = 2; + + + pub fn get_start_key_open(&self) -> &[u8] { + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_key_open(&mut self) { + self.start_key = ::std::option::Option::None; + } + + pub fn has_start_key_open(&self) -> bool { + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_key_open(&mut self, v: ::std::vec::Vec) { + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_key_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(_)) = self.start_key { + } else { + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(::std::vec::Vec::new())); + } + match self.start_key { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_key_open(&mut self) -> ::std::vec::Vec { + if self.has_start_key_open() { + match self.start_key.take() { + ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_key_open = 3; + + + pub fn get_end_key_open(&self) -> &[u8] { + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_key_open(&mut self) { + self.end_key = ::std::option::Option::None; + } + + pub fn has_end_key_open(&self) -> bool { + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_key_open(&mut self, v: ::std::vec::Vec) { + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_key_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(_)) = self.end_key { + } else { + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(::std::vec::Vec::new())); + } + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_key_open(&mut self) -> ::std::vec::Vec { + if self.has_end_key_open() { + match self.end_key.take() { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_key_closed = 4; + + + pub fn get_end_key_closed(&self) -> &[u8] { + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_key_closed(&mut self) { + self.end_key = ::std::option::Option::None; + } + + pub fn has_end_key_closed(&self) -> bool { + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_key_closed(&mut self, v: ::std::vec::Vec) { + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_key_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(_)) = self.end_key { + } else { + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(::std::vec::Vec::new())); + } + match self.end_key { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_key_closed(&mut self) -> ::std::vec::Vec { + if self.has_end_key_closed() { + match self.end_key.take() { + ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } +} + +impl ::protobuf::Message for RowRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_closed(is.read_bytes()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_key = ::std::option::Option::Some(RowRange_oneof_start_key::start_key_open(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_open(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_key = ::std::option::Option::Some(RowRange_oneof_end_key::end_key_closed(is.read_bytes()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.start_key { + match v { + &RowRange_oneof_start_key::start_key_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(1, &v); + }, + &RowRange_oneof_start_key::start_key_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_key { + match v { + &RowRange_oneof_end_key::end_key_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + &RowRange_oneof_end_key::end_key_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.start_key { + match v { + &RowRange_oneof_start_key::start_key_closed(ref v) => { + os.write_bytes(1, v)?; + }, + &RowRange_oneof_start_key::start_key_open(ref v) => { + os.write_bytes(2, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_key { + match v { + &RowRange_oneof_end_key::end_key_open(ref v) => { + os.write_bytes(3, v)?; + }, + &RowRange_oneof_end_key::end_key_closed(ref v) => { + os.write_bytes(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowRange { + RowRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_key_closed", + RowRange::has_start_key_closed, + RowRange::get_start_key_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_key_open", + RowRange::has_start_key_open, + RowRange::get_start_key_open, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_key_open", + RowRange::has_end_key_open, + RowRange::get_end_key_open, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_key_closed", + RowRange::has_end_key_closed, + RowRange::get_end_key_closed, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowRange, + }; + unsafe { + instance.get(RowRange::new) + } + } +} + +impl ::protobuf::Clear for RowRange { + fn clear(&mut self) { + self.start_key = ::std::option::Option::None; + self.start_key = ::std::option::Option::None; + self.end_key = ::std::option::Option::None; + self.end_key = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowSet { + // message fields + pub row_keys: ::protobuf::RepeatedField<::std::vec::Vec>, + pub row_ranges: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowSet { + fn default() -> &'a RowSet { + ::default_instance() + } +} + +impl RowSet { + pub fn new() -> RowSet { + ::std::default::Default::default() + } + + // repeated bytes row_keys = 1; + + + pub fn get_row_keys(&self) -> &[::std::vec::Vec] { + &self.row_keys + } + pub fn clear_row_keys(&mut self) { + self.row_keys.clear(); + } + + // Param is passed by value, moved + pub fn set_row_keys(&mut self, v: ::protobuf::RepeatedField<::std::vec::Vec>) { + self.row_keys = v; + } + + // Mutable pointer to the field. + pub fn mut_row_keys(&mut self) -> &mut ::protobuf::RepeatedField<::std::vec::Vec> { + &mut self.row_keys + } + + // Take field + pub fn take_row_keys(&mut self) -> ::protobuf::RepeatedField<::std::vec::Vec> { + ::std::mem::replace(&mut self.row_keys, ::protobuf::RepeatedField::new()) + } + + // repeated .google.bigtable.v2.RowRange row_ranges = 2; + + + pub fn get_row_ranges(&self) -> &[RowRange] { + &self.row_ranges + } + pub fn clear_row_ranges(&mut self) { + self.row_ranges.clear(); + } + + // Param is passed by value, moved + pub fn set_row_ranges(&mut self, v: ::protobuf::RepeatedField) { + self.row_ranges = v; + } + + // Mutable pointer to the field. + pub fn mut_row_ranges(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.row_ranges + } + + // Take field + pub fn take_row_ranges(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.row_ranges, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowSet { + fn is_initialized(&self) -> bool { + for v in &self.row_ranges { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_bytes_into(wire_type, is, &mut self.row_keys)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.row_ranges)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.row_keys { + my_size += ::protobuf::rt::bytes_size(1, &value); + }; + for value in &self.row_ranges { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.row_keys { + os.write_bytes(1, &v)?; + }; + for v in &self.row_ranges { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowSet { + RowSet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "row_keys", + |m: &RowSet| { &m.row_keys }, + |m: &mut RowSet| { &mut m.row_keys }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "row_ranges", + |m: &RowSet| { &m.row_ranges }, + |m: &mut RowSet| { &mut m.row_ranges }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowSet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowSet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowSet, + }; + unsafe { + instance.get(RowSet::new) + } + } +} + +impl ::protobuf::Clear for RowSet { + fn clear(&mut self) { + self.row_keys.clear(); + self.row_ranges.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowSet { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ColumnRange { + // message fields + pub family_name: ::std::string::String, + // message oneof groups + pub start_qualifier: ::std::option::Option, + pub end_qualifier: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ColumnRange { + fn default() -> &'a ColumnRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ColumnRange_oneof_start_qualifier { + start_qualifier_closed(::std::vec::Vec), + start_qualifier_open(::std::vec::Vec), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ColumnRange_oneof_end_qualifier { + end_qualifier_closed(::std::vec::Vec), + end_qualifier_open(::std::vec::Vec), +} + +impl ColumnRange { + pub fn new() -> ColumnRange { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes start_qualifier_closed = 2; + + + pub fn get_start_qualifier_closed(&self) -> &[u8] { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_qualifier_closed(&mut self) { + self.start_qualifier = ::std::option::Option::None; + } + + pub fn has_start_qualifier_closed(&self) -> bool { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_qualifier_closed(&mut self, v: ::std::vec::Vec) { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_qualifier_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(_)) = self.start_qualifier { + } else { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(::std::vec::Vec::new())); + } + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_qualifier_closed(&mut self) -> ::std::vec::Vec { + if self.has_start_qualifier_closed() { + match self.start_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes start_qualifier_open = 3; + + + pub fn get_start_qualifier_open(&self) -> &[u8] { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_qualifier_open(&mut self) { + self.start_qualifier = ::std::option::Option::None; + } + + pub fn has_start_qualifier_open(&self) -> bool { + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_qualifier_open(&mut self, v: ::std::vec::Vec) { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_qualifier_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(_)) = self.start_qualifier { + } else { + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(::std::vec::Vec::new())); + } + match self.start_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_qualifier_open(&mut self) -> ::std::vec::Vec { + if self.has_start_qualifier_open() { + match self.start_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_qualifier_closed = 4; + + + pub fn get_end_qualifier_closed(&self) -> &[u8] { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_qualifier_closed(&mut self) { + self.end_qualifier = ::std::option::Option::None; + } + + pub fn has_end_qualifier_closed(&self) -> bool { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_qualifier_closed(&mut self, v: ::std::vec::Vec) { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_qualifier_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(_)) = self.end_qualifier { + } else { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(::std::vec::Vec::new())); + } + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_qualifier_closed(&mut self) -> ::std::vec::Vec { + if self.has_end_qualifier_closed() { + match self.end_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_qualifier_open = 5; + + + pub fn get_end_qualifier_open(&self) -> &[u8] { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_qualifier_open(&mut self) { + self.end_qualifier = ::std::option::Option::None; + } + + pub fn has_end_qualifier_open(&self) -> bool { + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_qualifier_open(&mut self, v: ::std::vec::Vec) { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_qualifier_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(_)) = self.end_qualifier { + } else { + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(::std::vec::Vec::new())); + } + match self.end_qualifier { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_qualifier_open(&mut self) -> ::std::vec::Vec { + if self.has_end_qualifier_open() { + match self.end_qualifier.take() { + ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } +} + +impl ::protobuf::Message for ColumnRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_closed(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_qualifier = ::std::option::Option::Some(ColumnRange_oneof_start_qualifier::start_qualifier_open(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_closed(is.read_bytes()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_qualifier = ::std::option::Option::Some(ColumnRange_oneof_end_qualifier::end_qualifier_open(is.read_bytes()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if let ::std::option::Option::Some(ref v) = self.start_qualifier { + match v { + &ColumnRange_oneof_start_qualifier::start_qualifier_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &ColumnRange_oneof_start_qualifier::start_qualifier_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_qualifier { + match v { + &ColumnRange_oneof_end_qualifier::end_qualifier_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + &ColumnRange_oneof_end_qualifier::end_qualifier_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(5, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if let ::std::option::Option::Some(ref v) = self.start_qualifier { + match v { + &ColumnRange_oneof_start_qualifier::start_qualifier_closed(ref v) => { + os.write_bytes(2, v)?; + }, + &ColumnRange_oneof_start_qualifier::start_qualifier_open(ref v) => { + os.write_bytes(3, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_qualifier { + match v { + &ColumnRange_oneof_end_qualifier::end_qualifier_closed(ref v) => { + os.write_bytes(4, v)?; + }, + &ColumnRange_oneof_end_qualifier::end_qualifier_open(ref v) => { + os.write_bytes(5, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ColumnRange { + ColumnRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &ColumnRange| { &m.family_name }, + |m: &mut ColumnRange| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_qualifier_closed", + ColumnRange::has_start_qualifier_closed, + ColumnRange::get_start_qualifier_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_qualifier_open", + ColumnRange::has_start_qualifier_open, + ColumnRange::get_start_qualifier_open, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_qualifier_closed", + ColumnRange::has_end_qualifier_closed, + ColumnRange::get_end_qualifier_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_qualifier_open", + ColumnRange::has_end_qualifier_open, + ColumnRange::get_end_qualifier_open, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ColumnRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ColumnRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ColumnRange, + }; + unsafe { + instance.get(ColumnRange::new) + } + } +} + +impl ::protobuf::Clear for ColumnRange { + fn clear(&mut self) { + self.family_name.clear(); + self.start_qualifier = ::std::option::Option::None; + self.start_qualifier = ::std::option::Option::None; + self.end_qualifier = ::std::option::Option::None; + self.end_qualifier = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ColumnRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ColumnRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TimestampRange { + // message fields + pub start_timestamp_micros: i64, + pub end_timestamp_micros: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TimestampRange { + fn default() -> &'a TimestampRange { + ::default_instance() + } +} + +impl TimestampRange { + pub fn new() -> TimestampRange { + ::std::default::Default::default() + } + + // int64 start_timestamp_micros = 1; + + + pub fn get_start_timestamp_micros(&self) -> i64 { + self.start_timestamp_micros + } + pub fn clear_start_timestamp_micros(&mut self) { + self.start_timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_start_timestamp_micros(&mut self, v: i64) { + self.start_timestamp_micros = v; + } + + // int64 end_timestamp_micros = 2; + + + pub fn get_end_timestamp_micros(&self) -> i64 { + self.end_timestamp_micros + } + pub fn clear_end_timestamp_micros(&mut self) { + self.end_timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_end_timestamp_micros(&mut self, v: i64) { + self.end_timestamp_micros = v; + } +} + +impl ::protobuf::Message for TimestampRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.start_timestamp_micros = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.end_timestamp_micros = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.start_timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(1, self.start_timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if self.end_timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(2, self.end_timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.start_timestamp_micros != 0 { + os.write_int64(1, self.start_timestamp_micros)?; + } + if self.end_timestamp_micros != 0 { + os.write_int64(2, self.end_timestamp_micros)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TimestampRange { + TimestampRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "start_timestamp_micros", + |m: &TimestampRange| { &m.start_timestamp_micros }, + |m: &mut TimestampRange| { &mut m.start_timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "end_timestamp_micros", + |m: &TimestampRange| { &m.end_timestamp_micros }, + |m: &mut TimestampRange| { &mut m.end_timestamp_micros }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TimestampRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TimestampRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TimestampRange, + }; + unsafe { + instance.get(TimestampRange::new) + } + } +} + +impl ::protobuf::Clear for TimestampRange { + fn clear(&mut self) { + self.start_timestamp_micros = 0; + self.end_timestamp_micros = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TimestampRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TimestampRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ValueRange { + // message oneof groups + pub start_value: ::std::option::Option, + pub end_value: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ValueRange { + fn default() -> &'a ValueRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ValueRange_oneof_start_value { + start_value_closed(::std::vec::Vec), + start_value_open(::std::vec::Vec), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ValueRange_oneof_end_value { + end_value_closed(::std::vec::Vec), + end_value_open(::std::vec::Vec), +} + +impl ValueRange { + pub fn new() -> ValueRange { + ::std::default::Default::default() + } + + // bytes start_value_closed = 1; + + + pub fn get_start_value_closed(&self) -> &[u8] { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_value_closed(&mut self) { + self.start_value = ::std::option::Option::None; + } + + pub fn has_start_value_closed(&self) -> bool { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_value_closed(&mut self, v: ::std::vec::Vec) { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_value_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(_)) = self.start_value { + } else { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(::std::vec::Vec::new())); + } + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_value_closed(&mut self) -> ::std::vec::Vec { + if self.has_start_value_closed() { + match self.start_value.take() { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes start_value_open = 2; + + + pub fn get_start_value_open(&self) -> &[u8] { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_start_value_open(&mut self) { + self.start_value = ::std::option::Option::None; + } + + pub fn has_start_value_open(&self) -> bool { + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_value_open(&mut self, v: ::std::vec::Vec) { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_value_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(_)) = self.start_value { + } else { + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(::std::vec::Vec::new())); + } + match self.start_value { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_value_open(&mut self) -> ::std::vec::Vec { + if self.has_start_value_open() { + match self.start_value.take() { + ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_value_closed = 3; + + + pub fn get_end_value_closed(&self) -> &[u8] { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_value_closed(&mut self) { + self.end_value = ::std::option::Option::None; + } + + pub fn has_end_value_closed(&self) -> bool { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_value_closed(&mut self, v: ::std::vec::Vec) { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_value_closed(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(_)) = self.end_value { + } else { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(::std::vec::Vec::new())); + } + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_value_closed(&mut self) -> ::std::vec::Vec { + if self.has_end_value_closed() { + match self.end_value.take() { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // bytes end_value_open = 4; + + + pub fn get_end_value_open(&self) -> &[u8] { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(ref v)) => v, + _ => &[], + } + } + pub fn clear_end_value_open(&mut self) { + self.end_value = ::std::option::Option::None; + } + + pub fn has_end_value_open(&self) -> bool { + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_value_open(&mut self, v: ::std::vec::Vec) { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_value_open(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(_)) = self.end_value { + } else { + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(::std::vec::Vec::new())); + } + match self.end_value { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_value_open(&mut self) -> ::std::vec::Vec { + if self.has_end_value_open() { + match self.end_value.take() { + ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } +} + +impl ::protobuf::Message for ValueRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_closed(is.read_bytes()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_value = ::std::option::Option::Some(ValueRange_oneof_start_value::start_value_open(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_closed(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_value = ::std::option::Option::Some(ValueRange_oneof_end_value::end_value_open(is.read_bytes()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.start_value { + match v { + &ValueRange_oneof_start_value::start_value_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(1, &v); + }, + &ValueRange_oneof_start_value::start_value_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_value { + match v { + &ValueRange_oneof_end_value::end_value_closed(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + &ValueRange_oneof_end_value::end_value_open(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.start_value { + match v { + &ValueRange_oneof_start_value::start_value_closed(ref v) => { + os.write_bytes(1, v)?; + }, + &ValueRange_oneof_start_value::start_value_open(ref v) => { + os.write_bytes(2, v)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_value { + match v { + &ValueRange_oneof_end_value::end_value_closed(ref v) => { + os.write_bytes(3, v)?; + }, + &ValueRange_oneof_end_value::end_value_open(ref v) => { + os.write_bytes(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ValueRange { + ValueRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_value_closed", + ValueRange::has_start_value_closed, + ValueRange::get_start_value_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "start_value_open", + ValueRange::has_start_value_open, + ValueRange::get_start_value_open, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_value_closed", + ValueRange::has_end_value_closed, + ValueRange::get_end_value_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "end_value_open", + ValueRange::has_end_value_open, + ValueRange::get_end_value_open, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ValueRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ValueRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ValueRange, + }; + unsafe { + instance.get(ValueRange::new) + } + } +} + +impl ::protobuf::Clear for ValueRange { + fn clear(&mut self) { + self.start_value = ::std::option::Option::None; + self.start_value = ::std::option::Option::None; + self.end_value = ::std::option::Option::None; + self.end_value = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ValueRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ValueRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter { + // message oneof groups + pub filter: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter { + fn default() -> &'a RowFilter { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum RowFilter_oneof_filter { + chain(RowFilter_Chain), + interleave(RowFilter_Interleave), + condition(RowFilter_Condition), + sink(bool), + pass_all_filter(bool), + block_all_filter(bool), + row_key_regex_filter(::std::vec::Vec), + row_sample_filter(f64), + family_name_regex_filter(::std::string::String), + column_qualifier_regex_filter(::std::vec::Vec), + column_range_filter(ColumnRange), + timestamp_range_filter(TimestampRange), + value_regex_filter(::std::vec::Vec), + value_range_filter(ValueRange), + cells_per_row_offset_filter(i32), + cells_per_row_limit_filter(i32), + cells_per_column_limit_filter(i32), + strip_value_transformer(bool), + apply_label_transformer(::std::string::String), +} + +impl RowFilter { + pub fn new() -> RowFilter { + ::std::default::Default::default() + } + + // .google.bigtable.v2.RowFilter.Chain chain = 1; + + + pub fn get_chain(&self) -> &RowFilter_Chain { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(ref v)) => v, + _ => RowFilter_Chain::default_instance(), + } + } + pub fn clear_chain(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_chain(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_chain(&mut self, v: RowFilter_Chain) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(v)) + } + + // Mutable pointer to the field. + pub fn mut_chain(&mut self) -> &mut RowFilter_Chain { + if let ::std::option::Option::Some(RowFilter_oneof_filter::chain(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(RowFilter_Chain::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_chain(&mut self) -> RowFilter_Chain { + if self.has_chain() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::chain(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Chain::new() + } + } + + // .google.bigtable.v2.RowFilter.Interleave interleave = 2; + + + pub fn get_interleave(&self) -> &RowFilter_Interleave { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(ref v)) => v, + _ => RowFilter_Interleave::default_instance(), + } + } + pub fn clear_interleave(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_interleave(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_interleave(&mut self, v: RowFilter_Interleave) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(v)) + } + + // Mutable pointer to the field. + pub fn mut_interleave(&mut self) -> &mut RowFilter_Interleave { + if let ::std::option::Option::Some(RowFilter_oneof_filter::interleave(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(RowFilter_Interleave::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_interleave(&mut self) -> RowFilter_Interleave { + if self.has_interleave() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::interleave(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Interleave::new() + } + } + + // .google.bigtable.v2.RowFilter.Condition condition = 3; + + + pub fn get_condition(&self) -> &RowFilter_Condition { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(ref v)) => v, + _ => RowFilter_Condition::default_instance(), + } + } + pub fn clear_condition(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_condition(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_condition(&mut self, v: RowFilter_Condition) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(v)) + } + + // Mutable pointer to the field. + pub fn mut_condition(&mut self) -> &mut RowFilter_Condition { + if let ::std::option::Option::Some(RowFilter_oneof_filter::condition(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(RowFilter_Condition::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_condition(&mut self) -> RowFilter_Condition { + if self.has_condition() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::condition(v)) => v, + _ => panic!(), + } + } else { + RowFilter_Condition::new() + } + } + + // bool sink = 16; + + + pub fn get_sink(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::sink(v)) => v, + _ => false, + } + } + pub fn clear_sink(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_sink(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::sink(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_sink(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::sink(v)) + } + + // bool pass_all_filter = 17; + + + pub fn get_pass_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(v)) => v, + _ => false, + } + } + pub fn clear_pass_all_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_pass_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_pass_all_filter(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(v)) + } + + // bool block_all_filter = 18; + + + pub fn get_block_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(v)) => v, + _ => false, + } + } + pub fn clear_block_all_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_block_all_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_block_all_filter(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(v)) + } + + // bytes row_key_regex_filter = 4; + + + pub fn get_row_key_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_row_key_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_row_key_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_key_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_row_key_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_row_key_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_row_key_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // double row_sample_filter = 14; + + + pub fn get_row_sample_filter(&self) -> f64 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(v)) => v, + _ => 0., + } + } + pub fn clear_row_sample_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_row_sample_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_sample_filter(&mut self, v: f64) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(v)) + } + + // string family_name_regex_filter = 5; + + + pub fn get_family_name_regex_filter(&self) -> &str { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(ref v)) => v, + _ => "", + } + } + pub fn clear_family_name_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_family_name_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_family_name_regex_filter(&mut self, v: ::std::string::String) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_family_name_regex_filter(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(::std::string::String::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_family_name_regex_filter(&mut self) -> ::std::string::String { + if self.has_family_name_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } + + // bytes column_qualifier_regex_filter = 6; + + + pub fn get_column_qualifier_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_column_qualifier_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_column_qualifier_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_column_qualifier_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_column_qualifier_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_column_qualifier_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_column_qualifier_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.bigtable.v2.ColumnRange column_range_filter = 7; + + + pub fn get_column_range_filter(&self) -> &ColumnRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ref v)) => v, + _ => ColumnRange::default_instance(), + } + } + pub fn clear_column_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_column_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_column_range_filter(&mut self, v: ColumnRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_column_range_filter(&mut self) -> &mut ColumnRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ColumnRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_column_range_filter(&mut self) -> ColumnRange { + if self.has_column_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(v)) => v, + _ => panic!(), + } + } else { + ColumnRange::new() + } + } + + // .google.bigtable.v2.TimestampRange timestamp_range_filter = 8; + + + pub fn get_timestamp_range_filter(&self) -> &TimestampRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(ref v)) => v, + _ => TimestampRange::default_instance(), + } + } + pub fn clear_timestamp_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_timestamp_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_timestamp_range_filter(&mut self, v: TimestampRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_timestamp_range_filter(&mut self) -> &mut TimestampRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(TimestampRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_timestamp_range_filter(&mut self) -> TimestampRange { + if self.has_timestamp_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(v)) => v, + _ => panic!(), + } + } else { + TimestampRange::new() + } + } + + // bytes value_regex_filter = 9; + + + pub fn get_value_regex_filter(&self) -> &[u8] { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(ref v)) => v, + _ => &[], + } + } + pub fn clear_value_regex_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_value_regex_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_value_regex_filter(&mut self, v: ::std::vec::Vec) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_value_regex_filter(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(::std::vec::Vec::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_value_regex_filter(&mut self) -> ::std::vec::Vec { + if self.has_value_regex_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.bigtable.v2.ValueRange value_range_filter = 15; + + + pub fn get_value_range_filter(&self) -> &ValueRange { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ref v)) => v, + _ => ValueRange::default_instance(), + } + } + pub fn clear_value_range_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_value_range_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_value_range_filter(&mut self, v: ValueRange) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(v)) + } + + // Mutable pointer to the field. + pub fn mut_value_range_filter(&mut self) -> &mut ValueRange { + if let ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ValueRange::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_value_range_filter(&mut self) -> ValueRange { + if self.has_value_range_filter() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(v)) => v, + _ => panic!(), + } + } else { + ValueRange::new() + } + } + + // int32 cells_per_row_offset_filter = 10; + + + pub fn get_cells_per_row_offset_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_row_offset_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_row_offset_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_row_offset_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(v)) + } + + // int32 cells_per_row_limit_filter = 11; + + + pub fn get_cells_per_row_limit_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_row_limit_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_row_limit_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_row_limit_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(v)) + } + + // int32 cells_per_column_limit_filter = 12; + + + pub fn get_cells_per_column_limit_filter(&self) -> i32 { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(v)) => v, + _ => 0, + } + } + pub fn clear_cells_per_column_limit_filter(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_cells_per_column_limit_filter(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_cells_per_column_limit_filter(&mut self, v: i32) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(v)) + } + + // bool strip_value_transformer = 13; + + + pub fn get_strip_value_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(v)) => v, + _ => false, + } + } + pub fn clear_strip_value_transformer(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_strip_value_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_strip_value_transformer(&mut self, v: bool) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(v)) + } + + // string apply_label_transformer = 19; + + + pub fn get_apply_label_transformer(&self) -> &str { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(ref v)) => v, + _ => "", + } + } + pub fn clear_apply_label_transformer(&mut self) { + self.filter = ::std::option::Option::None; + } + + pub fn has_apply_label_transformer(&self) -> bool { + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_apply_label_transformer(&mut self, v: ::std::string::String) { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(v)) + } + + // Mutable pointer to the field. + pub fn mut_apply_label_transformer(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(_)) = self.filter { + } else { + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(::std::string::String::new())); + } + match self.filter { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_apply_label_transformer(&mut self) -> ::std::string::String { + if self.has_apply_label_transformer() { + match self.filter.take() { + ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } +} + +impl ::protobuf::Message for RowFilter { + fn is_initialized(&self) -> bool { + if let Some(RowFilter_oneof_filter::chain(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::interleave(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::condition(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::column_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::timestamp_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + if let Some(RowFilter_oneof_filter::value_range_filter(ref v)) = self.filter { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::chain(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::interleave(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::condition(is.read_message()?)); + }, + 16 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::sink(is.read_bool()?)); + }, + 17 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::pass_all_filter(is.read_bool()?)); + }, + 18 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::block_all_filter(is.read_bool()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_key_regex_filter(is.read_bytes()?)); + }, + 14 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::row_sample_filter(is.read_double()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::family_name_regex_filter(is.read_string()?)); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_qualifier_regex_filter(is.read_bytes()?)); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::column_range_filter(is.read_message()?)); + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::timestamp_range_filter(is.read_message()?)); + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_regex_filter(is.read_bytes()?)); + }, + 15 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::value_range_filter(is.read_message()?)); + }, + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_offset_filter(is.read_int32()?)); + }, + 11 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_row_limit_filter(is.read_int32()?)); + }, + 12 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::cells_per_column_limit_filter(is.read_int32()?)); + }, + 13 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::strip_value_transformer(is.read_bool()?)); + }, + 19 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.filter = ::std::option::Option::Some(RowFilter_oneof_filter::apply_label_transformer(is.read_string()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.filter { + match v { + &RowFilter_oneof_filter::chain(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::interleave(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::condition(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::sink(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::pass_all_filter(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::block_all_filter(v) => { + my_size += 3; + }, + &RowFilter_oneof_filter::row_key_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(4, &v); + }, + &RowFilter_oneof_filter::row_sample_filter(v) => { + my_size += 9; + }, + &RowFilter_oneof_filter::family_name_regex_filter(ref v) => { + my_size += ::protobuf::rt::string_size(5, &v); + }, + &RowFilter_oneof_filter::column_qualifier_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(6, &v); + }, + &RowFilter_oneof_filter::column_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::timestamp_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::value_regex_filter(ref v) => { + my_size += ::protobuf::rt::bytes_size(9, &v); + }, + &RowFilter_oneof_filter::value_range_filter(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &RowFilter_oneof_filter::cells_per_row_offset_filter(v) => { + my_size += ::protobuf::rt::value_size(10, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::cells_per_row_limit_filter(v) => { + my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::cells_per_column_limit_filter(v) => { + my_size += ::protobuf::rt::value_size(12, v, ::protobuf::wire_format::WireTypeVarint); + }, + &RowFilter_oneof_filter::strip_value_transformer(v) => { + my_size += 2; + }, + &RowFilter_oneof_filter::apply_label_transformer(ref v) => { + my_size += ::protobuf::rt::string_size(19, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.filter { + match v { + &RowFilter_oneof_filter::chain(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::interleave(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::condition(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::sink(v) => { + os.write_bool(16, v)?; + }, + &RowFilter_oneof_filter::pass_all_filter(v) => { + os.write_bool(17, v)?; + }, + &RowFilter_oneof_filter::block_all_filter(v) => { + os.write_bool(18, v)?; + }, + &RowFilter_oneof_filter::row_key_regex_filter(ref v) => { + os.write_bytes(4, v)?; + }, + &RowFilter_oneof_filter::row_sample_filter(v) => { + os.write_double(14, v)?; + }, + &RowFilter_oneof_filter::family_name_regex_filter(ref v) => { + os.write_string(5, v)?; + }, + &RowFilter_oneof_filter::column_qualifier_regex_filter(ref v) => { + os.write_bytes(6, v)?; + }, + &RowFilter_oneof_filter::column_range_filter(ref v) => { + os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::timestamp_range_filter(ref v) => { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::value_regex_filter(ref v) => { + os.write_bytes(9, v)?; + }, + &RowFilter_oneof_filter::value_range_filter(ref v) => { + os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &RowFilter_oneof_filter::cells_per_row_offset_filter(v) => { + os.write_int32(10, v)?; + }, + &RowFilter_oneof_filter::cells_per_row_limit_filter(v) => { + os.write_int32(11, v)?; + }, + &RowFilter_oneof_filter::cells_per_column_limit_filter(v) => { + os.write_int32(12, v)?; + }, + &RowFilter_oneof_filter::strip_value_transformer(v) => { + os.write_bool(13, v)?; + }, + &RowFilter_oneof_filter::apply_label_transformer(ref v) => { + os.write_string(19, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter { + RowFilter::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Chain>( + "chain", + RowFilter::has_chain, + RowFilter::get_chain, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Interleave>( + "interleave", + RowFilter::has_interleave, + RowFilter::get_interleave, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RowFilter_Condition>( + "condition", + RowFilter::has_condition, + RowFilter::get_condition, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "sink", + RowFilter::has_sink, + RowFilter::get_sink, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "pass_all_filter", + RowFilter::has_pass_all_filter, + RowFilter::get_pass_all_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "block_all_filter", + RowFilter::has_block_all_filter, + RowFilter::get_block_all_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "row_key_regex_filter", + RowFilter::has_row_key_regex_filter, + RowFilter::get_row_key_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>( + "row_sample_filter", + RowFilter::has_row_sample_filter, + RowFilter::get_row_sample_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "family_name_regex_filter", + RowFilter::has_family_name_regex_filter, + RowFilter::get_family_name_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "column_qualifier_regex_filter", + RowFilter::has_column_qualifier_regex_filter, + RowFilter::get_column_qualifier_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ColumnRange>( + "column_range_filter", + RowFilter::has_column_range_filter, + RowFilter::get_column_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TimestampRange>( + "timestamp_range_filter", + RowFilter::has_timestamp_range_filter, + RowFilter::get_timestamp_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "value_regex_filter", + RowFilter::has_value_regex_filter, + RowFilter::get_value_regex_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ValueRange>( + "value_range_filter", + RowFilter::has_value_range_filter, + RowFilter::get_value_range_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_row_offset_filter", + RowFilter::has_cells_per_row_offset_filter, + RowFilter::get_cells_per_row_offset_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_row_limit_filter", + RowFilter::has_cells_per_row_limit_filter, + RowFilter::get_cells_per_row_limit_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>( + "cells_per_column_limit_filter", + RowFilter::has_cells_per_column_limit_filter, + RowFilter::get_cells_per_column_limit_filter, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "strip_value_transformer", + RowFilter::has_strip_value_transformer, + RowFilter::get_strip_value_transformer, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "apply_label_transformer", + RowFilter::has_apply_label_transformer, + RowFilter::get_apply_label_transformer, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter, + }; + unsafe { + instance.get(RowFilter::new) + } + } +} + +impl ::protobuf::Clear for RowFilter { + fn clear(&mut self) { + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.filter = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Chain { + // message fields + pub filters: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Chain { + fn default() -> &'a RowFilter_Chain { + ::default_instance() + } +} + +impl RowFilter_Chain { + pub fn new() -> RowFilter_Chain { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v2.RowFilter filters = 1; + + + pub fn get_filters(&self) -> &[RowFilter] { + &self.filters + } + pub fn clear_filters(&mut self) { + self.filters.clear(); + } + + // Param is passed by value, moved + pub fn set_filters(&mut self, v: ::protobuf::RepeatedField) { + self.filters = v; + } + + // Mutable pointer to the field. + pub fn mut_filters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.filters + } + + // Take field + pub fn take_filters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.filters, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowFilter_Chain { + fn is_initialized(&self) -> bool { + for v in &self.filters { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filters)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.filters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.filters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Chain { + RowFilter_Chain::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filters", + |m: &RowFilter_Chain| { &m.filters }, + |m: &mut RowFilter_Chain| { &mut m.filters }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Chain", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Chain { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Chain, + }; + unsafe { + instance.get(RowFilter_Chain::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Chain { + fn clear(&mut self) { + self.filters.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Chain { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Chain { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Interleave { + // message fields + pub filters: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Interleave { + fn default() -> &'a RowFilter_Interleave { + ::default_instance() + } +} + +impl RowFilter_Interleave { + pub fn new() -> RowFilter_Interleave { + ::std::default::Default::default() + } + + // repeated .google.bigtable.v2.RowFilter filters = 1; + + + pub fn get_filters(&self) -> &[RowFilter] { + &self.filters + } + pub fn clear_filters(&mut self) { + self.filters.clear(); + } + + // Param is passed by value, moved + pub fn set_filters(&mut self, v: ::protobuf::RepeatedField) { + self.filters = v; + } + + // Mutable pointer to the field. + pub fn mut_filters(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.filters + } + + // Take field + pub fn take_filters(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.filters, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for RowFilter_Interleave { + fn is_initialized(&self) -> bool { + for v in &self.filters { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.filters)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.filters { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.filters { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Interleave { + RowFilter_Interleave::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "filters", + |m: &RowFilter_Interleave| { &m.filters }, + |m: &mut RowFilter_Interleave| { &mut m.filters }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Interleave", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Interleave { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Interleave, + }; + unsafe { + instance.get(RowFilter_Interleave::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Interleave { + fn clear(&mut self) { + self.filters.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Interleave { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Interleave { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RowFilter_Condition { + // message fields + pub predicate_filter: ::protobuf::SingularPtrField, + pub true_filter: ::protobuf::SingularPtrField, + pub false_filter: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RowFilter_Condition { + fn default() -> &'a RowFilter_Condition { + ::default_instance() + } +} + +impl RowFilter_Condition { + pub fn new() -> RowFilter_Condition { + ::std::default::Default::default() + } + + // .google.bigtable.v2.RowFilter predicate_filter = 1; + + + pub fn get_predicate_filter(&self) -> &RowFilter { + self.predicate_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_predicate_filter(&mut self) { + self.predicate_filter.clear(); + } + + pub fn has_predicate_filter(&self) -> bool { + self.predicate_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_predicate_filter(&mut self, v: RowFilter) { + self.predicate_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_predicate_filter(&mut self) -> &mut RowFilter { + if self.predicate_filter.is_none() { + self.predicate_filter.set_default(); + } + self.predicate_filter.as_mut().unwrap() + } + + // Take field + pub fn take_predicate_filter(&mut self) -> RowFilter { + self.predicate_filter.take().unwrap_or_else(|| RowFilter::new()) + } + + // .google.bigtable.v2.RowFilter true_filter = 2; + + + pub fn get_true_filter(&self) -> &RowFilter { + self.true_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_true_filter(&mut self) { + self.true_filter.clear(); + } + + pub fn has_true_filter(&self) -> bool { + self.true_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_true_filter(&mut self, v: RowFilter) { + self.true_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_true_filter(&mut self) -> &mut RowFilter { + if self.true_filter.is_none() { + self.true_filter.set_default(); + } + self.true_filter.as_mut().unwrap() + } + + // Take field + pub fn take_true_filter(&mut self) -> RowFilter { + self.true_filter.take().unwrap_or_else(|| RowFilter::new()) + } + + // .google.bigtable.v2.RowFilter false_filter = 3; + + + pub fn get_false_filter(&self) -> &RowFilter { + self.false_filter.as_ref().unwrap_or_else(|| RowFilter::default_instance()) + } + pub fn clear_false_filter(&mut self) { + self.false_filter.clear(); + } + + pub fn has_false_filter(&self) -> bool { + self.false_filter.is_some() + } + + // Param is passed by value, moved + pub fn set_false_filter(&mut self, v: RowFilter) { + self.false_filter = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_false_filter(&mut self) -> &mut RowFilter { + if self.false_filter.is_none() { + self.false_filter.set_default(); + } + self.false_filter.as_mut().unwrap() + } + + // Take field + pub fn take_false_filter(&mut self) -> RowFilter { + self.false_filter.take().unwrap_or_else(|| RowFilter::new()) + } +} + +impl ::protobuf::Message for RowFilter_Condition { + fn is_initialized(&self) -> bool { + for v in &self.predicate_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.true_filter { + if !v.is_initialized() { + return false; + } + }; + for v in &self.false_filter { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.predicate_filter)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.true_filter)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.false_filter)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.predicate_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.true_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.false_filter.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.predicate_filter.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.true_filter.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.false_filter.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RowFilter_Condition { + RowFilter_Condition::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "predicate_filter", + |m: &RowFilter_Condition| { &m.predicate_filter }, + |m: &mut RowFilter_Condition| { &mut m.predicate_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "true_filter", + |m: &RowFilter_Condition| { &m.true_filter }, + |m: &mut RowFilter_Condition| { &mut m.true_filter }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "false_filter", + |m: &RowFilter_Condition| { &m.false_filter }, + |m: &mut RowFilter_Condition| { &mut m.false_filter }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RowFilter_Condition", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RowFilter_Condition { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RowFilter_Condition, + }; + unsafe { + instance.get(RowFilter_Condition::new) + } + } +} + +impl ::protobuf::Clear for RowFilter_Condition { + fn clear(&mut self) { + self.predicate_filter.clear(); + self.true_filter.clear(); + self.false_filter.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RowFilter_Condition { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RowFilter_Condition { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation { + // message oneof groups + pub mutation: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation { + fn default() -> &'a Mutation { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum Mutation_oneof_mutation { + set_cell(Mutation_SetCell), + delete_from_column(Mutation_DeleteFromColumn), + delete_from_family(Mutation_DeleteFromFamily), + delete_from_row(Mutation_DeleteFromRow), +} + +impl Mutation { + pub fn new() -> Mutation { + ::std::default::Default::default() + } + + // .google.bigtable.v2.Mutation.SetCell set_cell = 1; + + + pub fn get_set_cell(&self) -> &Mutation_SetCell { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(ref v)) => v, + _ => Mutation_SetCell::default_instance(), + } + } + pub fn clear_set_cell(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_set_cell(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_set_cell(&mut self, v: Mutation_SetCell) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(v)) + } + + // Mutable pointer to the field. + pub fn mut_set_cell(&mut self) -> &mut Mutation_SetCell { + if let ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(Mutation_SetCell::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_set_cell(&mut self) -> Mutation_SetCell { + if self.has_set_cell() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(v)) => v, + _ => panic!(), + } + } else { + Mutation_SetCell::new() + } + } + + // .google.bigtable.v2.Mutation.DeleteFromColumn delete_from_column = 2; + + + pub fn get_delete_from_column(&self) -> &Mutation_DeleteFromColumn { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(ref v)) => v, + _ => Mutation_DeleteFromColumn::default_instance(), + } + } + pub fn clear_delete_from_column(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_column(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_column(&mut self, v: Mutation_DeleteFromColumn) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_column(&mut self) -> &mut Mutation_DeleteFromColumn { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(Mutation_DeleteFromColumn::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_column(&mut self) -> Mutation_DeleteFromColumn { + if self.has_delete_from_column() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromColumn::new() + } + } + + // .google.bigtable.v2.Mutation.DeleteFromFamily delete_from_family = 3; + + + pub fn get_delete_from_family(&self) -> &Mutation_DeleteFromFamily { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(ref v)) => v, + _ => Mutation_DeleteFromFamily::default_instance(), + } + } + pub fn clear_delete_from_family(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_family(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_family(&mut self, v: Mutation_DeleteFromFamily) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_family(&mut self) -> &mut Mutation_DeleteFromFamily { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(Mutation_DeleteFromFamily::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_family(&mut self) -> Mutation_DeleteFromFamily { + if self.has_delete_from_family() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromFamily::new() + } + } + + // .google.bigtable.v2.Mutation.DeleteFromRow delete_from_row = 4; + + + pub fn get_delete_from_row(&self) -> &Mutation_DeleteFromRow { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(ref v)) => v, + _ => Mutation_DeleteFromRow::default_instance(), + } + } + pub fn clear_delete_from_row(&mut self) { + self.mutation = ::std::option::Option::None; + } + + pub fn has_delete_from_row(&self) -> bool { + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete_from_row(&mut self, v: Mutation_DeleteFromRow) { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete_from_row(&mut self) -> &mut Mutation_DeleteFromRow { + if let ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(_)) = self.mutation { + } else { + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(Mutation_DeleteFromRow::new())); + } + match self.mutation { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete_from_row(&mut self) -> Mutation_DeleteFromRow { + if self.has_delete_from_row() { + match self.mutation.take() { + ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(v)) => v, + _ => panic!(), + } + } else { + Mutation_DeleteFromRow::new() + } + } +} + +impl ::protobuf::Message for Mutation { + fn is_initialized(&self) -> bool { + if let Some(Mutation_oneof_mutation::set_cell(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_column(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_family(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_mutation::delete_from_row(ref v)) = self.mutation { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::set_cell(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_column(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_family(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mutation = ::std::option::Option::Some(Mutation_oneof_mutation::delete_from_row(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.mutation { + match v { + &Mutation_oneof_mutation::set_cell(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_column(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_family(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_mutation::delete_from_row(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.mutation { + match v { + &Mutation_oneof_mutation::set_cell(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_column(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_family(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_mutation::delete_from_row(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation { + Mutation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_SetCell>( + "set_cell", + Mutation::has_set_cell, + Mutation::get_set_cell, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromColumn>( + "delete_from_column", + Mutation::has_delete_from_column, + Mutation::get_delete_from_column, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromFamily>( + "delete_from_family", + Mutation::has_delete_from_family, + Mutation::get_delete_from_family, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_DeleteFromRow>( + "delete_from_row", + Mutation::has_delete_from_row, + Mutation::get_delete_from_row, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation, + }; + unsafe { + instance.get(Mutation::new) + } + } +} + +impl ::protobuf::Clear for Mutation { + fn clear(&mut self) { + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.mutation = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_SetCell { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + pub timestamp_micros: i64, + pub value: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_SetCell { + fn default() -> &'a Mutation_SetCell { + ::default_instance() + } +} + +impl Mutation_SetCell { + pub fn new() -> Mutation_SetCell { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // int64 timestamp_micros = 3; + + + pub fn get_timestamp_micros(&self) -> i64 { + self.timestamp_micros + } + pub fn clear_timestamp_micros(&mut self) { + self.timestamp_micros = 0; + } + + // Param is passed by value, moved + pub fn set_timestamp_micros(&mut self, v: i64) { + self.timestamp_micros = v; + } + + // bytes value = 4; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for Mutation_SetCell { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.timestamp_micros = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if self.timestamp_micros != 0 { + my_size += ::protobuf::rt::value_size(3, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint); + } + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(4, &self.value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if self.timestamp_micros != 0 { + os.write_int64(3, self.timestamp_micros)?; + } + if !self.value.is_empty() { + os.write_bytes(4, &self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_SetCell { + Mutation_SetCell::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_SetCell| { &m.family_name }, + |m: &mut Mutation_SetCell| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &Mutation_SetCell| { &m.column_qualifier }, + |m: &mut Mutation_SetCell| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "timestamp_micros", + |m: &Mutation_SetCell| { &m.timestamp_micros }, + |m: &mut Mutation_SetCell| { &mut m.timestamp_micros }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &Mutation_SetCell| { &m.value }, + |m: &mut Mutation_SetCell| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_SetCell", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_SetCell { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_SetCell, + }; + unsafe { + instance.get(Mutation_SetCell::new) + } + } +} + +impl ::protobuf::Clear for Mutation_SetCell { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.timestamp_micros = 0; + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_SetCell { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_SetCell { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromColumn { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + pub time_range: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromColumn { + fn default() -> &'a Mutation_DeleteFromColumn { + ::default_instance() + } +} + +impl Mutation_DeleteFromColumn { + pub fn new() -> Mutation_DeleteFromColumn { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // .google.bigtable.v2.TimestampRange time_range = 3; + + + pub fn get_time_range(&self) -> &TimestampRange { + self.time_range.as_ref().unwrap_or_else(|| TimestampRange::default_instance()) + } + pub fn clear_time_range(&mut self) { + self.time_range.clear(); + } + + pub fn has_time_range(&self) -> bool { + self.time_range.is_some() + } + + // Param is passed by value, moved + pub fn set_time_range(&mut self, v: TimestampRange) { + self.time_range = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_time_range(&mut self) -> &mut TimestampRange { + if self.time_range.is_none() { + self.time_range.set_default(); + } + self.time_range.as_mut().unwrap() + } + + // Take field + pub fn take_time_range(&mut self) -> TimestampRange { + self.time_range.take().unwrap_or_else(|| TimestampRange::new()) + } +} + +impl ::protobuf::Message for Mutation_DeleteFromColumn { + fn is_initialized(&self) -> bool { + for v in &self.time_range { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.time_range)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if let Some(ref v) = self.time_range.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if let Some(ref v) = self.time_range.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromColumn { + Mutation_DeleteFromColumn::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_DeleteFromColumn| { &m.family_name }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &Mutation_DeleteFromColumn| { &m.column_qualifier }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "time_range", + |m: &Mutation_DeleteFromColumn| { &m.time_range }, + |m: &mut Mutation_DeleteFromColumn| { &mut m.time_range }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromColumn", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromColumn { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromColumn, + }; + unsafe { + instance.get(Mutation_DeleteFromColumn::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromColumn { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.time_range.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromColumn { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromColumn { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromFamily { + // message fields + pub family_name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromFamily { + fn default() -> &'a Mutation_DeleteFromFamily { + ::default_instance() + } +} + +impl Mutation_DeleteFromFamily { + pub fn new() -> Mutation_DeleteFromFamily { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Mutation_DeleteFromFamily { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromFamily { + Mutation_DeleteFromFamily::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &Mutation_DeleteFromFamily| { &m.family_name }, + |m: &mut Mutation_DeleteFromFamily| { &mut m.family_name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromFamily", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromFamily { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromFamily, + }; + unsafe { + instance.get(Mutation_DeleteFromFamily::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromFamily { + fn clear(&mut self) { + self.family_name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromFamily { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromFamily { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_DeleteFromRow { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_DeleteFromRow { + fn default() -> &'a Mutation_DeleteFromRow { + ::default_instance() + } +} + +impl Mutation_DeleteFromRow { + pub fn new() -> Mutation_DeleteFromRow { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for Mutation_DeleteFromRow { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_DeleteFromRow { + Mutation_DeleteFromRow::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_DeleteFromRow", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_DeleteFromRow { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_DeleteFromRow, + }; + unsafe { + instance.get(Mutation_DeleteFromRow::new) + } + } +} + +impl ::protobuf::Clear for Mutation_DeleteFromRow { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_DeleteFromRow { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_DeleteFromRow { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadModifyWriteRule { + // message fields + pub family_name: ::std::string::String, + pub column_qualifier: ::std::vec::Vec, + // message oneof groups + pub rule: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadModifyWriteRule { + fn default() -> &'a ReadModifyWriteRule { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ReadModifyWriteRule_oneof_rule { + append_value(::std::vec::Vec), + increment_amount(i64), +} + +impl ReadModifyWriteRule { + pub fn new() -> ReadModifyWriteRule { + ::std::default::Default::default() + } + + // string family_name = 1; + + + pub fn get_family_name(&self) -> &str { + &self.family_name + } + pub fn clear_family_name(&mut self) { + self.family_name.clear(); + } + + // Param is passed by value, moved + pub fn set_family_name(&mut self, v: ::std::string::String) { + self.family_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_family_name(&mut self) -> &mut ::std::string::String { + &mut self.family_name + } + + // Take field + pub fn take_family_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.family_name, ::std::string::String::new()) + } + + // bytes column_qualifier = 2; + + + pub fn get_column_qualifier(&self) -> &[u8] { + &self.column_qualifier + } + pub fn clear_column_qualifier(&mut self) { + self.column_qualifier.clear(); + } + + // Param is passed by value, moved + pub fn set_column_qualifier(&mut self, v: ::std::vec::Vec) { + self.column_qualifier = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_column_qualifier(&mut self) -> &mut ::std::vec::Vec { + &mut self.column_qualifier + } + + // Take field + pub fn take_column_qualifier(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.column_qualifier, ::std::vec::Vec::new()) + } + + // bytes append_value = 3; + + + pub fn get_append_value(&self) -> &[u8] { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(ref v)) => v, + _ => &[], + } + } + pub fn clear_append_value(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_append_value(&self) -> bool { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_append_value(&mut self, v: ::std::vec::Vec) { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_append_value(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(_)) = self.rule { + } else { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(::std::vec::Vec::new())); + } + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_append_value(&mut self) -> ::std::vec::Vec { + if self.has_append_value() { + match self.rule.take() { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // int64 increment_amount = 4; + + + pub fn get_increment_amount(&self) -> i64 { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(v)) => v, + _ => 0, + } + } + pub fn clear_increment_amount(&mut self) { + self.rule = ::std::option::Option::None; + } + + pub fn has_increment_amount(&self) -> bool { + match self.rule { + ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_increment_amount(&mut self, v: i64) { + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(v)) + } +} + +impl ::protobuf::Message for ReadModifyWriteRule { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.family_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.column_qualifier)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::append_value(is.read_bytes()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.rule = ::std::option::Option::Some(ReadModifyWriteRule_oneof_rule::increment_amount(is.read_int64()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.family_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.family_name); + } + if !self.column_qualifier.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.column_qualifier); + } + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &ReadModifyWriteRule_oneof_rule::append_value(ref v) => { + my_size += ::protobuf::rt::bytes_size(3, &v); + }, + &ReadModifyWriteRule_oneof_rule::increment_amount(v) => { + my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.family_name.is_empty() { + os.write_string(1, &self.family_name)?; + } + if !self.column_qualifier.is_empty() { + os.write_bytes(2, &self.column_qualifier)?; + } + if let ::std::option::Option::Some(ref v) = self.rule { + match v { + &ReadModifyWriteRule_oneof_rule::append_value(ref v) => { + os.write_bytes(3, v)?; + }, + &ReadModifyWriteRule_oneof_rule::increment_amount(v) => { + os.write_int64(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadModifyWriteRule { + ReadModifyWriteRule::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "family_name", + |m: &ReadModifyWriteRule| { &m.family_name }, + |m: &mut ReadModifyWriteRule| { &mut m.family_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "column_qualifier", + |m: &ReadModifyWriteRule| { &m.column_qualifier }, + |m: &mut ReadModifyWriteRule| { &mut m.column_qualifier }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "append_value", + ReadModifyWriteRule::has_append_value, + ReadModifyWriteRule::get_append_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>( + "increment_amount", + ReadModifyWriteRule::has_increment_amount, + ReadModifyWriteRule::get_increment_amount, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadModifyWriteRule", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadModifyWriteRule { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadModifyWriteRule, + }; + unsafe { + instance.get(ReadModifyWriteRule::new) + } + } +} + +impl ::protobuf::Clear for ReadModifyWriteRule { + fn clear(&mut self) { + self.family_name.clear(); + self.column_qualifier.clear(); + self.rule = ::std::option::Option::None; + self.rule = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadModifyWriteRule { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRule { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1dgoogle/bigtable/v2/data.proto\x12\x12google.bigtable.v2\"O\n\x03Ro\ + w\x12\x10\n\x03key\x18\x01\x20\x01(\x0cR\x03key\x126\n\x08families\x18\ + \x02\x20\x03(\x0b2\x1a.google.bigtable.v2.FamilyR\x08families\"R\n\x06Fa\ + mily\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x124\n\x07columns\x18\ + \x02\x20\x03(\x0b2\x1a.google.bigtable.v2.ColumnR\x07columns\"V\n\x06Col\ + umn\x12\x1c\n\tqualifier\x18\x01\x20\x01(\x0cR\tqualifier\x12.\n\x05cell\ + s\x18\x02\x20\x03(\x0b2\x18.google.bigtable.v2.CellR\x05cells\"_\n\x04Ce\ + ll\x12)\n\x10timestamp_micros\x18\x01\x20\x01(\x03R\x0ftimestampMicros\ + \x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05value\x12\x16\n\x06labels\ + \x18\x03\x20\x03(\tR\x06labels\"\xc2\x01\n\x08RowRange\x12*\n\x10start_k\ + ey_closed\x18\x01\x20\x01(\x0cH\0R\x0estartKeyClosed\x12&\n\x0estart_key\ + _open\x18\x02\x20\x01(\x0cH\0R\x0cstartKeyOpen\x12\"\n\x0cend_key_open\ + \x18\x03\x20\x01(\x0cH\x01R\nendKeyOpen\x12&\n\x0eend_key_closed\x18\x04\ + \x20\x01(\x0cH\x01R\x0cendKeyClosedB\x0b\n\tstart_keyB\t\n\x07end_key\"`\ + \n\x06RowSet\x12\x19\n\x08row_keys\x18\x01\x20\x03(\x0cR\x07rowKeys\x12;\ + \n\nrow_ranges\x18\x02\x20\x03(\x0b2\x1c.google.bigtable.v2.RowRangeR\tr\ + owRanges\"\xa2\x02\n\x0bColumnRange\x12\x1f\n\x0bfamily_name\x18\x01\x20\ + \x01(\tR\nfamilyName\x126\n\x16start_qualifier_closed\x18\x02\x20\x01(\ + \x0cH\0R\x14startQualifierClosed\x122\n\x14start_qualifier_open\x18\x03\ + \x20\x01(\x0cH\0R\x12startQualifierOpen\x122\n\x14end_qualifier_closed\ + \x18\x04\x20\x01(\x0cH\x01R\x12endQualifierClosed\x12.\n\x12end_qualifie\ + r_open\x18\x05\x20\x01(\x0cH\x01R\x10endQualifierOpenB\x11\n\x0fstart_qu\ + alifierB\x0f\n\rend_qualifier\"x\n\x0eTimestampRange\x124\n\x16start_tim\ + estamp_micros\x18\x01\x20\x01(\x03R\x14startTimestampMicros\x120\n\x14en\ + d_timestamp_micros\x18\x02\x20\x01(\x03R\x12endTimestampMicros\"\xd8\x01\ + \n\nValueRange\x12.\n\x12start_value_closed\x18\x01\x20\x01(\x0cH\0R\x10\ + startValueClosed\x12*\n\x10start_value_open\x18\x02\x20\x01(\x0cH\0R\x0e\ + startValueOpen\x12*\n\x10end_value_closed\x18\x03\x20\x01(\x0cH\x01R\x0e\ + endValueClosed\x12&\n\x0eend_value_open\x18\x04\x20\x01(\x0cH\x01R\x0cen\ + dValueOpenB\r\n\x0bstart_valueB\x0b\n\tend_value\"\xfc\x0b\n\tRowFilter\ + \x12;\n\x05chain\x18\x01\x20\x01(\x0b2#.google.bigtable.v2.RowFilter.Cha\ + inH\0R\x05chain\x12J\n\ninterleave\x18\x02\x20\x01(\x0b2(.google.bigtabl\ + e.v2.RowFilter.InterleaveH\0R\ninterleave\x12G\n\tcondition\x18\x03\x20\ + \x01(\x0b2'.google.bigtable.v2.RowFilter.ConditionH\0R\tcondition\x12\ + \x14\n\x04sink\x18\x10\x20\x01(\x08H\0R\x04sink\x12(\n\x0fpass_all_filte\ + r\x18\x11\x20\x01(\x08H\0R\rpassAllFilter\x12*\n\x10block_all_filter\x18\ + \x12\x20\x01(\x08H\0R\x0eblockAllFilter\x121\n\x14row_key_regex_filter\ + \x18\x04\x20\x01(\x0cH\0R\x11rowKeyRegexFilter\x12,\n\x11row_sample_filt\ + er\x18\x0e\x20\x01(\x01H\0R\x0frowSampleFilter\x129\n\x18family_name_reg\ + ex_filter\x18\x05\x20\x01(\tH\0R\x15familyNameRegexFilter\x12C\n\x1dcolu\ + mn_qualifier_regex_filter\x18\x06\x20\x01(\x0cH\0R\x1acolumnQualifierReg\ + exFilter\x12Q\n\x13column_range_filter\x18\x07\x20\x01(\x0b2\x1f.google.\ + bigtable.v2.ColumnRangeH\0R\x11columnRangeFilter\x12Z\n\x16timestamp_ran\ + ge_filter\x18\x08\x20\x01(\x0b2\".google.bigtable.v2.TimestampRangeH\0R\ + \x14timestampRangeFilter\x12.\n\x12value_regex_filter\x18\t\x20\x01(\x0c\ + H\0R\x10valueRegexFilter\x12N\n\x12value_range_filter\x18\x0f\x20\x01(\ + \x0b2\x1e.google.bigtable.v2.ValueRangeH\0R\x10valueRangeFilter\x12>\n\ + \x1bcells_per_row_offset_filter\x18\n\x20\x01(\x05H\0R\x17cellsPerRowOff\ + setFilter\x12<\n\x1acells_per_row_limit_filter\x18\x0b\x20\x01(\x05H\0R\ + \x16cellsPerRowLimitFilter\x12B\n\x1dcells_per_column_limit_filter\x18\ + \x0c\x20\x01(\x05H\0R\x19cellsPerColumnLimitFilter\x128\n\x17strip_value\ + _transformer\x18\r\x20\x01(\x08H\0R\x15stripValueTransformer\x128\n\x17a\ + pply_label_transformer\x18\x13\x20\x01(\tH\0R\x15applyLabelTransformer\ + \x1a@\n\x05Chain\x127\n\x07filters\x18\x01\x20\x03(\x0b2\x1d.google.bigt\ + able.v2.RowFilterR\x07filters\x1aE\n\nInterleave\x127\n\x07filters\x18\ + \x01\x20\x03(\x0b2\x1d.google.bigtable.v2.RowFilterR\x07filters\x1a\xd7\ + \x01\n\tCondition\x12H\n\x10predicate_filter\x18\x01\x20\x01(\x0b2\x1d.g\ + oogle.bigtable.v2.RowFilterR\x0fpredicateFilter\x12>\n\x0btrue_filter\ + \x18\x02\x20\x01(\x0b2\x1d.google.bigtable.v2.RowFilterR\ntrueFilter\x12\ + @\n\x0cfalse_filter\x18\x03\x20\x01(\x0b2\x1d.google.bigtable.v2.RowFilt\ + erR\x0bfalseFilterB\x08\n\x06filter\"\xf0\x05\n\x08Mutation\x12A\n\x08se\ + t_cell\x18\x01\x20\x01(\x0b2$.google.bigtable.v2.Mutation.SetCellH\0R\ + \x07setCell\x12]\n\x12delete_from_column\x18\x02\x20\x01(\x0b2-.google.b\ + igtable.v2.Mutation.DeleteFromColumnH\0R\x10deleteFromColumn\x12]\n\x12d\ + elete_from_family\x18\x03\x20\x01(\x0b2-.google.bigtable.v2.Mutation.Del\ + eteFromFamilyH\0R\x10deleteFromFamily\x12T\n\x0fdelete_from_row\x18\x04\ + \x20\x01(\x0b2*.google.bigtable.v2.Mutation.DeleteFromRowH\0R\rdeleteFro\ + mRow\x1a\x96\x01\n\x07SetCell\x12\x1f\n\x0bfamily_name\x18\x01\x20\x01(\ + \tR\nfamilyName\x12)\n\x10column_qualifier\x18\x02\x20\x01(\x0cR\x0fcolu\ + mnQualifier\x12)\n\x10timestamp_micros\x18\x03\x20\x01(\x03R\x0ftimestam\ + pMicros\x12\x14\n\x05value\x18\x04\x20\x01(\x0cR\x05value\x1a\xa1\x01\n\ + \x10DeleteFromColumn\x12\x1f\n\x0bfamily_name\x18\x01\x20\x01(\tR\nfamil\ + yName\x12)\n\x10column_qualifier\x18\x02\x20\x01(\x0cR\x0fcolumnQualifie\ + r\x12A\n\ntime_range\x18\x03\x20\x01(\x0b2\".google.bigtable.v2.Timestam\ + pRangeR\ttimeRange\x1a3\n\x10DeleteFromFamily\x12\x1f\n\x0bfamily_name\ + \x18\x01\x20\x01(\tR\nfamilyName\x1a\x0f\n\rDeleteFromRowB\n\n\x08mutati\ + on\"\xbb\x01\n\x13ReadModifyWriteRule\x12\x1f\n\x0bfamily_name\x18\x01\ + \x20\x01(\tR\nfamilyName\x12)\n\x10column_qualifier\x18\x02\x20\x01(\x0c\ + R\x0fcolumnQualifier\x12#\n\x0cappend_value\x18\x03\x20\x01(\x0cH\0R\x0b\ + appendValue\x12+\n\x10increment_amount\x18\x04\x20\x01(\x03H\0R\x0fincre\ + mentAmountB\x06\n\x04ruleB\x97\x01\n\x16com.google.bigtable.v2B\tDataPro\ + toP\x01Z:google.golang.org/genproto/googleapis/bigtable/v2;bigtable\xaa\ + \x02\x18Google.Cloud.Bigtable.V2\xca\x02\x18Google\\Cloud\\Bigtable\\V2J\ + \x9f\xb8\x01\n\x07\x12\x05\x0e\0\x96\x04\x01\n\xbd\x04\n\x01\x0c\x12\x03\ + \x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\n\x20Licens\ + ed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"\ + License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\x20i\ + n\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20\ + a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://ww\ + w.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20app\ + licable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20\ + distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\ + \x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITION\ + S\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\ + \x20the\x20License\x20for\x20the\x20specific\x20language\x20governing\ + \x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\n\n\ + \x08\n\x01\x02\x12\x03\x10\0\x1b\n\x08\n\x01\x08\x12\x03\x12\05\n\t\n\ + \x02\x08%\x12\x03\x12\05\n\x08\n\x01\x08\x12\x03\x13\0Q\n\t\n\x02\x08\ + \x0b\x12\x03\x13\0Q\n\x08\n\x01\x08\x12\x03\x14\0\"\n\t\n\x02\x08\n\x12\ + \x03\x14\0\"\n\x08\n\x01\x08\x12\x03\x15\0*\n\t\n\x02\x08\x08\x12\x03\ + \x15\0*\n\x08\n\x01\x08\x12\x03\x16\0/\n\t\n\x02\x08\x01\x12\x03\x16\0/\ + \n\x08\n\x01\x08\x12\x03\x17\05\n\t\n\x02\x08)\x12\x03\x17\05\n\x90\x01\ + \n\x02\x04\0\x12\x04\x1c\0%\x01\x1a\x83\x01\x20Specifies\x20the\x20compl\ + ete\x20(requested)\x20contents\x20of\x20a\x20single\x20row\x20of\x20a\ + \x20table.\n\x20Rows\x20which\x20exceed\x20256MiB\x20in\x20size\x20canno\ + t\x20be\x20read\x20in\x20full.\n\n\n\n\x03\x04\0\x01\x12\x03\x1c\x08\x0b\ + \n\xe2\x01\n\x04\x04\0\x02\0\x12\x03\x20\x02\x10\x1a\xd4\x01\x20The\x20u\ + nique\x20key\x20which\x20identifies\x20this\x20row\x20within\x20its\x20t\ + able.\x20This\x20is\x20the\x20same\n\x20key\x20that's\x20used\x20to\x20i\ + dentify\x20the\x20row\x20in,\x20for\x20example,\x20a\x20MutateRowRequest\ + .\n\x20May\x20contain\x20any\x20non-empty\x20byte\x20string\x20up\x20to\ + \x204KiB\x20in\x20length.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04\x20\x02\ + \x1c\r\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x20\x02\x07\n\x0c\n\x05\x04\0\ + \x02\0\x01\x12\x03\x20\x08\x0b\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x20\ + \x0e\x0f\n{\n\x04\x04\0\x02\x01\x12\x03$\x02\x1f\x1an\x20May\x20be\x20em\ + pty,\x20but\x20only\x20if\x20the\x20entire\x20row\x20is\x20empty.\n\x20T\ + he\x20mutual\x20ordering\x20of\x20column\x20families\x20is\x20not\x20spe\ + cified.\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03$\x02\n\n\x0c\n\x05\x04\0\ + \x02\x01\x06\x12\x03$\x0b\x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03$\x12\ + \x1a\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03$\x1d\x1e\nf\n\x02\x04\x01\x12\ + \x04)\04\x01\x1aZ\x20Specifies\x20(some\x20of)\x20the\x20contents\x20of\ + \x20a\x20single\x20row/column\x20family\x20intersection\n\x20of\x20a\x20\ + table.\n\n\n\n\x03\x04\x01\x01\x12\x03)\x08\x0e\n\x85\x03\n\x04\x04\x01\ + \x02\0\x12\x030\x02\x12\x1a\xf7\x02\x20The\x20unique\x20key\x20which\x20\ + identifies\x20this\x20family\x20within\x20its\x20row.\x20This\x20is\x20t\ + he\n\x20same\x20key\x20that's\x20used\x20to\x20identify\x20the\x20family\ + \x20in,\x20for\x20example,\x20a\x20RowFilter\n\x20which\x20sets\x20its\ + \x20\"family_name_regex_filter\"\x20field.\n\x20Must\x20match\x20`[-_.a-\ + zA-Z0-9]+`,\x20except\x20that\x20AggregatingRowProcessors\x20may\n\x20pr\ + oduce\x20cells\x20in\x20a\x20sentinel\x20family\x20with\x20an\x20empty\ + \x20name.\n\x20Must\x20be\x20no\x20greater\x20than\x2064\x20characters\ + \x20in\x20length.\n\n\r\n\x05\x04\x01\x02\0\x04\x12\x040\x02)\x10\n\x0c\ + \n\x05\x04\x01\x02\0\x05\x12\x030\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\ + \x12\x030\t\r\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x030\x10\x11\nL\n\x04\ + \x04\x01\x02\x01\x12\x033\x02\x1e\x1a?\x20Must\x20not\x20be\x20empty.\ + \x20Sorted\x20in\x20order\x20of\x20increasing\x20\"qualifier\".\n\n\x0c\ + \n\x05\x04\x01\x02\x01\x04\x12\x033\x02\n\n\x0c\n\x05\x04\x01\x02\x01\ + \x06\x12\x033\x0b\x11\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x033\x12\x19\n\ + \x0c\n\x05\x04\x01\x02\x01\x03\x12\x033\x1c\x1d\n_\n\x02\x04\x02\x12\x04\ + 8\0B\x01\x1aS\x20Specifies\x20(some\x20of)\x20the\x20contents\x20of\x20a\ + \x20single\x20row/column\x20intersection\x20of\x20a\n\x20table.\n\n\n\n\ + \x03\x04\x02\x01\x12\x038\x08\x0e\n\xad\x02\n\x04\x04\x02\x02\0\x12\x03>\ + \x02\x16\x1a\x9f\x02\x20The\x20unique\x20key\x20which\x20identifies\x20t\ + his\x20column\x20within\x20its\x20family.\x20This\x20is\x20the\n\x20same\ + \x20key\x20that's\x20used\x20to\x20identify\x20the\x20column\x20in,\x20f\ + or\x20example,\x20a\x20RowFilter\n\x20which\x20sets\x20its\x20`column_qu\ + alifier_regex_filter`\x20field.\n\x20May\x20contain\x20any\x20byte\x20st\ + ring,\x20including\x20the\x20empty\x20string,\x20up\x20to\x2016kiB\x20in\ + \n\x20length.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04>\x028\x10\n\x0c\n\ + \x05\x04\x02\x02\0\x05\x12\x03>\x02\x07\n\x0c\n\x05\x04\x02\x02\0\x01\ + \x12\x03>\x08\x11\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03>\x14\x15\nS\n\ + \x04\x04\x02\x02\x01\x12\x03A\x02\x1a\x1aF\x20Must\x20not\x20be\x20empty\ + .\x20Sorted\x20in\x20order\x20of\x20decreasing\x20\"timestamp_micros\".\ + \n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03A\x02\n\n\x0c\n\x05\x04\x02\ + \x02\x01\x06\x12\x03A\x0b\x0f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03A\ + \x10\x15\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03A\x18\x19\n[\n\x02\x04\ + \x03\x12\x04E\0U\x01\x1aO\x20Specifies\x20(some\x20of)\x20the\x20content\ + s\x20of\x20a\x20single\x20row/column/timestamp\x20of\x20a\x20table.\n\n\ + \n\n\x03\x04\x03\x01\x12\x03E\x08\x0c\n\xf6\x02\n\x04\x04\x03\x02\0\x12\ + \x03L\x02\x1d\x1a\xe8\x02\x20The\x20cell's\x20stored\x20timestamp,\x20wh\ + ich\x20also\x20uniquely\x20identifies\x20it\x20within\n\x20its\x20column\ + .\n\x20Values\x20are\x20always\x20expressed\x20in\x20microseconds,\x20bu\ + t\x20individual\x20tables\x20may\x20set\n\x20a\x20coarser\x20granularity\ + \x20to\x20further\x20restrict\x20the\x20allowed\x20values.\x20For\n\x20e\ + xample,\x20a\x20table\x20which\x20specifies\x20millisecond\x20granularit\ + y\x20will\x20only\x20allow\n\x20values\x20of\x20`timestamp_micros`\x20wh\ + ich\x20are\x20multiples\x20of\x201000.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\ + \x04L\x02E\x0e\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03L\x02\x07\n\x0c\n\ + \x05\x04\x03\x02\0\x01\x12\x03L\x08\x18\n\x0c\n\x05\x04\x03\x02\0\x03\ + \x12\x03L\x1b\x1c\n\x7f\n\x04\x04\x03\x02\x01\x12\x03Q\x02\x12\x1ar\x20T\ + he\x20value\x20stored\x20in\x20the\x20cell.\n\x20May\x20contain\x20any\ + \x20byte\x20string,\x20including\x20the\x20empty\x20string,\x20up\x20to\ + \x20100MiB\x20in\n\x20length.\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04Q\ + \x02L\x1d\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03Q\x02\x07\n\x0c\n\x05\ + \x04\x03\x02\x01\x01\x12\x03Q\x08\r\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\ + \x03Q\x10\x11\nY\n\x04\x04\x03\x02\x02\x12\x03T\x02\x1d\x1aL\x20Labels\ + \x20applied\x20to\x20the\x20cell\x20by\x20a\x20[RowFilter][google.bigtab\ + le.v2.RowFilter].\n\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03T\x02\n\n\x0c\ + \n\x05\x04\x03\x02\x02\x05\x12\x03T\x0b\x11\n\x0c\n\x05\x04\x03\x02\x02\ + \x01\x12\x03T\x12\x18\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03T\x1b\x1c\n\ + 3\n\x02\x04\x04\x12\x04X\0l\x01\x1a'\x20Specifies\x20a\x20contiguous\x20\ + range\x20of\x20rows.\n\n\n\n\x03\x04\x04\x01\x12\x03X\x08\x10\n~\n\x04\ + \x04\x04\x08\0\x12\x04[\x02a\x03\x1ap\x20The\x20row\x20key\x20at\x20whic\ + h\x20to\x20start\x20the\x20range.\n\x20If\x20neither\x20field\x20is\x20s\ + et,\x20interpreted\x20as\x20the\x20empty\x20string,\x20inclusive.\n\n\ + \x0c\n\x05\x04\x04\x08\0\x01\x12\x03[\x08\x11\nG\n\x04\x04\x04\x02\0\x12\ + \x03]\x04\x1f\x1a:\x20Used\x20when\x20giving\x20an\x20inclusive\x20lower\ + \x20bound\x20for\x20the\x20range.\n\n\x0c\n\x05\x04\x04\x02\0\x05\x12\ + \x03]\x04\t\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03]\n\x1a\n\x0c\n\x05\x04\ + \x04\x02\0\x03\x12\x03]\x1d\x1e\nG\n\x04\x04\x04\x02\x01\x12\x03`\x04\ + \x1d\x1a:\x20Used\x20when\x20giving\x20an\x20exclusive\x20lower\x20bound\ + \x20for\x20the\x20range.\n\n\x0c\n\x05\x04\x04\x02\x01\x05\x12\x03`\x04\ + \t\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03`\n\x18\n\x0c\n\x05\x04\x04\ + \x02\x01\x03\x12\x03`\x1b\x1c\n\x80\x01\n\x04\x04\x04\x08\x01\x12\x04e\ + \x02k\x03\x1ar\x20The\x20row\x20key\x20at\x20which\x20to\x20end\x20the\ + \x20range.\n\x20If\x20neither\x20field\x20is\x20set,\x20interpreted\x20a\ + s\x20the\x20infinite\x20row\x20key,\x20exclusive.\n\n\x0c\n\x05\x04\x04\ + \x08\x01\x01\x12\x03e\x08\x0f\nG\n\x04\x04\x04\x02\x02\x12\x03g\x04\x1b\ + \x1a:\x20Used\x20when\x20giving\x20an\x20exclusive\x20upper\x20bound\x20\ + for\x20the\x20range.\n\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x03g\x04\t\n\ + \x0c\n\x05\x04\x04\x02\x02\x01\x12\x03g\n\x16\n\x0c\n\x05\x04\x04\x02\ + \x02\x03\x12\x03g\x19\x1a\nG\n\x04\x04\x04\x02\x03\x12\x03j\x04\x1d\x1a:\ + \x20Used\x20when\x20giving\x20an\x20inclusive\x20upper\x20bound\x20for\ + \x20the\x20range.\n\n\x0c\n\x05\x04\x04\x02\x03\x05\x12\x03j\x04\t\n\x0c\ + \n\x05\x04\x04\x02\x03\x01\x12\x03j\n\x18\n\x0c\n\x05\x04\x04\x02\x03\ + \x03\x12\x03j\x1b\x1c\n5\n\x02\x04\x05\x12\x04o\0u\x01\x1a)\x20Specifies\ + \x20a\x20non-contiguous\x20set\x20of\x20rows.\n\n\n\n\x03\x04\x05\x01\ + \x12\x03o\x08\x0e\n/\n\x04\x04\x05\x02\0\x12\x03q\x02\x1e\x1a\"\x20Singl\ + e\x20rows\x20included\x20in\x20the\x20set.\n\n\x0c\n\x05\x04\x05\x02\0\ + \x04\x12\x03q\x02\n\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03q\x0b\x10\n\x0c\ + \n\x05\x04\x05\x02\0\x01\x12\x03q\x11\x19\n\x0c\n\x05\x04\x05\x02\0\x03\ + \x12\x03q\x1c\x1d\n9\n\x04\x04\x05\x02\x01\x12\x03t\x02#\x1a,\x20Contigu\ + ous\x20row\x20ranges\x20included\x20in\x20the\x20set.\n\n\x0c\n\x05\x04\ + \x05\x02\x01\x04\x12\x03t\x02\n\n\x0c\n\x05\x04\x05\x02\x01\x06\x12\x03t\ + \x0b\x13\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03t\x14\x1e\n\x0c\n\x05\ + \x04\x05\x02\x01\x03\x12\x03t!\"\n\x84\x02\n\x02\x04\x06\x12\x05{\0\x92\ + \x01\x01\x1a\xf6\x01\x20Specifies\x20a\x20contiguous\x20range\x20of\x20c\ + olumns\x20within\x20a\x20single\x20column\x20family.\n\x20The\x20range\ + \x20spans\x20from\x20<column_family>:<start_qualifier>\x20to\ + \n\x20<column_family>:<end_qualifier>,\x20where\x20both\x20b\ + ounds\x20can\x20be\x20either\n\x20inclusive\x20or\x20exclusive.\n\n\n\n\ + \x03\x04\x06\x01\x12\x03{\x08\x13\nK\n\x04\x04\x06\x02\0\x12\x03}\x02\ + \x19\x1a>\x20The\x20name\x20of\x20the\x20column\x20family\x20within\x20w\ + hich\x20this\x20range\x20falls.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04}\ + \x02{\x15\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03}\x02\x08\n\x0c\n\x05\x04\ + \x06\x02\0\x01\x12\x03}\t\x14\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03}\x17\ + \x18\n\xa3\x01\n\x04\x04\x06\x08\0\x12\x06\x81\x01\x02\x87\x01\x03\x1a\ + \x92\x01\x20The\x20column\x20qualifier\x20at\x20which\x20to\x20start\x20\ + the\x20range\x20(within\x20`column_family`).\n\x20If\x20neither\x20field\ + \x20is\x20set,\x20interpreted\x20as\x20the\x20empty\x20string,\x20inclus\ + ive.\n\n\r\n\x05\x04\x06\x08\0\x01\x12\x04\x81\x01\x08\x17\nH\n\x04\x04\ + \x06\x02\x01\x12\x04\x83\x01\x04%\x1a:\x20Used\x20when\x20giving\x20an\ + \x20inclusive\x20lower\x20bound\x20for\x20the\x20range.\n\n\r\n\x05\x04\ + \x06\x02\x01\x05\x12\x04\x83\x01\x04\t\n\r\n\x05\x04\x06\x02\x01\x01\x12\ + \x04\x83\x01\n\x20\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\x83\x01#$\nH\n\ + \x04\x04\x06\x02\x02\x12\x04\x86\x01\x04#\x1a:\x20Used\x20when\x20giving\ + \x20an\x20exclusive\x20lower\x20bound\x20for\x20the\x20range.\n\n\r\n\ + \x05\x04\x06\x02\x02\x05\x12\x04\x86\x01\x04\t\n\r\n\x05\x04\x06\x02\x02\ + \x01\x12\x04\x86\x01\n\x1e\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\x86\x01\ + !\"\n\xa4\x01\n\x04\x04\x06\x08\x01\x12\x06\x8b\x01\x02\x91\x01\x03\x1a\ + \x93\x01\x20The\x20column\x20qualifier\x20at\x20which\x20to\x20end\x20th\ + e\x20range\x20(within\x20`column_family`).\n\x20If\x20neither\x20field\ + \x20is\x20set,\x20interpreted\x20as\x20the\x20infinite\x20string,\x20exc\ + lusive.\n\n\r\n\x05\x04\x06\x08\x01\x01\x12\x04\x8b\x01\x08\x15\nH\n\x04\ + \x04\x06\x02\x03\x12\x04\x8d\x01\x04#\x1a:\x20Used\x20when\x20giving\x20\ + an\x20inclusive\x20upper\x20bound\x20for\x20the\x20range.\n\n\r\n\x05\ + \x04\x06\x02\x03\x05\x12\x04\x8d\x01\x04\t\n\r\n\x05\x04\x06\x02\x03\x01\ + \x12\x04\x8d\x01\n\x1e\n\r\n\x05\x04\x06\x02\x03\x03\x12\x04\x8d\x01!\"\ + \nH\n\x04\x04\x06\x02\x04\x12\x04\x90\x01\x04!\x1a:\x20Used\x20when\x20g\ + iving\x20an\x20exclusive\x20upper\x20bound\x20for\x20the\x20range.\n\n\r\ + \n\x05\x04\x06\x02\x04\x05\x12\x04\x90\x01\x04\t\n\r\n\x05\x04\x06\x02\ + \x04\x01\x12\x04\x90\x01\n\x1c\n\r\n\x05\x04\x06\x02\x04\x03\x12\x04\x90\ + \x01\x1f\x20\nG\n\x02\x04\x07\x12\x06\x95\x01\0\x9b\x01\x01\x1a9\x20Spec\ + ified\x20a\x20contiguous\x20range\x20of\x20microsecond\x20timestamps.\n\ + \n\x0b\n\x03\x04\x07\x01\x12\x04\x95\x01\x08\x16\nG\n\x04\x04\x07\x02\0\ + \x12\x04\x97\x01\x02#\x1a9\x20Inclusive\x20lower\x20bound.\x20If\x20left\ + \x20empty,\x20interpreted\x20as\x200.\n\n\x0f\n\x05\x04\x07\x02\0\x04\ + \x12\x06\x97\x01\x02\x95\x01\x18\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\x97\ + \x01\x02\x07\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\x97\x01\x08\x1e\n\r\n\ + \x05\x04\x07\x02\0\x03\x12\x04\x97\x01!\"\nN\n\x04\x04\x07\x02\x01\x12\ + \x04\x9a\x01\x02!\x1a@\x20Exclusive\x20upper\x20bound.\x20If\x20left\x20\ + empty,\x20interpreted\x20as\x20infinity.\n\n\x0f\n\x05\x04\x07\x02\x01\ + \x04\x12\x06\x9a\x01\x02\x97\x01#\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\ + \x9a\x01\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x9a\x01\x08\x1c\n\ + \r\n\x05\x04\x07\x02\x01\x03\x12\x04\x9a\x01\x1f\x20\n@\n\x02\x04\x08\ + \x12\x06\x9e\x01\0\xb2\x01\x01\x1a2\x20Specifies\x20a\x20contiguous\x20r\ + ange\x20of\x20raw\x20byte\x20values.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\ + \x9e\x01\x08\x12\n~\n\x04\x04\x08\x08\0\x12\x06\xa1\x01\x02\xa7\x01\x03\ + \x1an\x20The\x20value\x20at\x20which\x20to\x20start\x20the\x20range.\n\ + \x20If\x20neither\x20field\x20is\x20set,\x20interpreted\x20as\x20the\x20\ + empty\x20string,\x20inclusive.\n\n\r\n\x05\x04\x08\x08\0\x01\x12\x04\xa1\ + \x01\x08\x13\nH\n\x04\x04\x08\x02\0\x12\x04\xa3\x01\x04!\x1a:\x20Used\ + \x20when\x20giving\x20an\x20inclusive\x20lower\x20bound\x20for\x20the\ + \x20range.\n\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\xa3\x01\x04\t\n\r\n\x05\ + \x04\x08\x02\0\x01\x12\x04\xa3\x01\n\x1c\n\r\n\x05\x04\x08\x02\0\x03\x12\ + \x04\xa3\x01\x1f\x20\nH\n\x04\x04\x08\x02\x01\x12\x04\xa6\x01\x04\x1f\ + \x1a:\x20Used\x20when\x20giving\x20an\x20exclusive\x20lower\x20bound\x20\ + for\x20the\x20range.\n\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xa6\x01\x04\ + \t\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\xa6\x01\n\x1a\n\r\n\x05\x04\x08\ + \x02\x01\x03\x12\x04\xa6\x01\x1d\x1e\n\x7f\n\x04\x04\x08\x08\x01\x12\x06\ + \xab\x01\x02\xb1\x01\x03\x1ao\x20The\x20value\x20at\x20which\x20to\x20en\ + d\x20the\x20range.\n\x20If\x20neither\x20field\x20is\x20set,\x20interpre\ + ted\x20as\x20the\x20infinite\x20string,\x20exclusive.\n\n\r\n\x05\x04\ + \x08\x08\x01\x01\x12\x04\xab\x01\x08\x11\nH\n\x04\x04\x08\x02\x02\x12\ + \x04\xad\x01\x04\x1f\x1a:\x20Used\x20when\x20giving\x20an\x20inclusive\ + \x20upper\x20bound\x20for\x20the\x20range.\n\n\r\n\x05\x04\x08\x02\x02\ + \x05\x12\x04\xad\x01\x04\t\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\xad\x01\ + \n\x1a\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xad\x01\x1d\x1e\nH\n\x04\ + \x04\x08\x02\x03\x12\x04\xb0\x01\x04\x1d\x1a:\x20Used\x20when\x20giving\ + \x20an\x20exclusive\x20upper\x20bound\x20for\x20the\x20range.\n\n\r\n\ + \x05\x04\x08\x02\x03\x05\x12\x04\xb0\x01\x04\t\n\r\n\x05\x04\x08\x02\x03\ + \x01\x12\x04\xb0\x01\n\x18\n\r\n\x05\x04\x08\x02\x03\x03\x12\x04\xb0\x01\ + \x1b\x1c\n\xa9\x0f\n\x02\x04\t\x12\x06\xd5\x01\0\xb8\x03\x01\x1a\x9a\x0f\ + \x20Takes\x20a\x20row\x20as\x20input\x20and\x20produces\x20an\x20alterna\ + te\x20view\x20of\x20the\x20row\x20based\x20on\n\x20specified\x20rules.\ + \x20For\x20example,\x20a\x20RowFilter\x20might\x20trim\x20down\x20a\x20r\ + ow\x20to\x20include\n\x20just\x20the\x20cells\x20from\x20columns\x20matc\ + hing\x20a\x20given\x20regular\x20expression,\x20or\x20might\n\x20return\ + \x20all\x20the\x20cells\x20of\x20a\x20row\x20but\x20not\x20their\x20valu\ + es.\x20More\x20complicated\x20filters\n\x20can\x20be\x20composed\x20out\ + \x20of\x20these\x20components\x20to\x20express\x20requests\x20such\x20as\ + ,\x20\"within\n\x20every\x20column\x20of\x20a\x20particular\x20family,\ + \x20give\x20just\x20the\x20two\x20most\x20recent\x20cells\n\x20which\x20\ + are\x20older\x20than\x20timestamp\x20X.\"\n\n\x20There\x20are\x20two\x20\ + broad\x20categories\x20of\x20RowFilters\x20(true\x20filters\x20and\x20tr\ + ansformers),\n\x20as\x20well\x20as\x20two\x20ways\x20to\x20compose\x20si\ + mple\x20filters\x20into\x20more\x20complex\x20ones\n\x20(chains\x20and\ + \x20interleaves).\x20They\x20work\x20as\x20follows:\n\n\x20*\x20True\x20\ + filters\x20alter\x20the\x20input\x20row\x20by\x20excluding\x20some\x20of\ + \x20its\x20cells\x20wholesale\n\x20from\x20the\x20output\x20row.\x20An\ + \x20example\x20of\x20a\x20true\x20filter\x20is\x20the\x20`value_regex_fi\ + lter`,\n\x20which\x20excludes\x20cells\x20whose\x20values\x20don't\x20ma\ + tch\x20the\x20specified\x20pattern.\x20All\n\x20regex\x20true\x20filters\ + \x20use\x20RE2\x20syntax\x20(https://github.com/google/re2/wiki/Syntax)\ + \n\x20in\x20raw\x20byte\x20mode\x20(RE2::Latin1),\x20and\x20are\x20evalu\ + ated\x20as\x20full\x20matches.\x20An\n\x20important\x20point\x20to\x20ke\ + ep\x20in\x20mind\x20is\x20that\x20`RE2(.)`\x20is\x20equivalent\x20by\x20\ + default\x20to\n\x20`RE2([^\\n])`,\x20meaning\x20that\x20it\x20does\x20no\ + t\x20match\x20newlines.\x20When\x20attempting\x20to\n\x20match\x20an\x20\ + arbitrary\x20byte,\x20you\x20should\x20therefore\x20use\x20the\x20escape\ + \x20sequence\x20`\\C`,\n\x20which\x20may\x20need\x20to\x20be\x20further\ + \x20escaped\x20as\x20`\\\\C`\x20in\x20your\x20client\x20language.\n\n\ + \x20*\x20Transformers\x20alter\x20the\x20input\x20row\x20by\x20changing\ + \x20the\x20values\x20of\x20some\x20of\x20its\n\x20cells\x20in\x20the\x20\ + output,\x20without\x20excluding\x20them\x20completely.\x20Currently,\x20\ + the\x20only\n\x20supported\x20transformer\x20is\x20the\x20`strip_value_t\ + ransformer`,\x20which\x20replaces\x20every\n\x20cell's\x20value\x20with\ + \x20the\x20empty\x20string.\n\n\x20*\x20Chains\x20and\x20interleaves\x20\ + are\x20described\x20in\x20more\x20detail\x20in\x20the\n\x20RowFilter.Cha\ + in\x20and\x20RowFilter.Interleave\x20documentation.\n\n\x20The\x20total\ + \x20serialized\x20size\x20of\x20a\x20RowFilter\x20message\x20must\x20not\ + \n\x20exceed\x204096\x20bytes,\x20and\x20RowFilters\x20may\x20not\x20be\ + \x20nested\x20within\x20each\x20other\n\x20(in\x20Chains\x20or\x20Interl\ + eaves)\x20to\x20a\x20depth\x20of\x20more\x20than\x2020.\n\n\x0b\n\x03\ + \x04\t\x01\x12\x04\xd5\x01\x08\x11\nV\n\x04\x04\t\x03\0\x12\x06\xd7\x01\ + \x02\xdc\x01\x03\x1aF\x20A\x20RowFilter\x20which\x20sends\x20rows\x20thr\ + ough\x20several\x20RowFilters\x20in\x20sequence.\n\n\r\n\x05\x04\t\x03\0\ + \x01\x12\x04\xd7\x01\n\x0f\n\xc9\x01\n\x06\x04\t\x03\0\x02\0\x12\x04\xdb\ + \x01\x04#\x1a\xb8\x01\x20The\x20elements\x20of\x20\"filters\"\x20are\x20\ + chained\x20together\x20to\x20process\x20the\x20input\x20row:\n\x20in\x20\ + row\x20->\x20f(0)\x20->\x20intermediate\x20row\x20->\x20f(1)\x20->\x20..\ + .\x20->\x20f(N)\x20->\x20out\x20row\n\x20The\x20full\x20chain\x20is\x20e\ + xecuted\x20atomically.\n\n\x0f\n\x07\x04\t\x03\0\x02\0\x04\x12\x04\xdb\ + \x01\x04\x0c\n\x0f\n\x07\x04\t\x03\0\x02\0\x06\x12\x04\xdb\x01\r\x16\n\ + \x0f\n\x07\x04\t\x03\0\x02\0\x01\x12\x04\xdb\x01\x17\x1e\n\x0f\n\x07\x04\ + \t\x03\0\x02\0\x03\x12\x04\xdb\x01!\"\nx\n\x04\x04\t\x03\x01\x12\x06\xe0\ + \x01\x02\xfb\x01\x03\x1ah\x20A\x20RowFilter\x20which\x20sends\x20each\ + \x20row\x20to\x20each\x20of\x20several\x20component\n\x20RowFilters\x20a\ + nd\x20interleaves\x20the\x20results.\n\n\r\n\x05\x04\t\x03\x01\x01\x12\ + \x04\xe0\x01\n\x14\n\x93\x0b\n\x06\x04\t\x03\x01\x02\0\x12\x04\xfa\x01\ + \x04#\x1a\x82\x0b\x20The\x20elements\x20of\x20\"filters\"\x20all\x20proc\ + ess\x20a\x20copy\x20of\x20the\x20input\x20row,\x20and\x20the\n\x20result\ + s\x20are\x20pooled,\x20sorted,\x20and\x20combined\x20into\x20a\x20single\ + \x20output\x20row.\n\x20If\x20multiple\x20cells\x20are\x20produced\x20wi\ + th\x20the\x20same\x20column\x20and\x20timestamp,\n\x20they\x20will\x20al\ + l\x20appear\x20in\x20the\x20output\x20row\x20in\x20an\x20unspecified\x20\ + mutual\x20order.\n\x20Consider\x20the\x20following\x20example,\x20with\ + \x20three\x20filters:\n\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20input\x20row\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20------------------------------------------------\ + -----\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20f(0)\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20f(1)\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20f(2)\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x201:\x20foo,bar\ + ,10,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20foo,bar,10,z\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,bar,7,a\n\ + \x20\x20\x20\x20\x202:\x20foo,blah,11,z\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20far,blah,5,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20far,blah,5,x\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20------------------------\ + -----------------------------\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x201:\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20foo,bar,10,z\x20\x20\x20//\x20could\x20have\x20switched\x20w\ + ith\x20#2\n\x20\x20\x20\x20\x202:\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20foo,bar,10,x\x20\x20\ + \x20//\x20could\x20have\x20switched\x20with\x20#1\n\x20\x20\x20\x20\x203\ + :\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20foo,blah,11,z\n\x20\x20\x20\x20\x204:\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20far,bar,7,a\n\x20\x20\x20\x20\x205:\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20far,blah,5,x\x20\ + \x20\x20//\x20identical\x20to\x20#6\n\x20\x20\x20\x20\x206:\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20far,blah,5,x\x20\x20\x20//\x20identical\x20to\x20#5\n\n\x20All\x20in\ + terleaved\x20filters\x20are\x20executed\x20atomically.\n\n\x0f\n\x07\x04\ + \t\x03\x01\x02\0\x04\x12\x04\xfa\x01\x04\x0c\n\x0f\n\x07\x04\t\x03\x01\ + \x02\0\x06\x12\x04\xfa\x01\r\x16\n\x0f\n\x07\x04\t\x03\x01\x02\0\x01\x12\ + \x04\xfa\x01\x17\x1e\n\x0f\n\x07\x04\t\x03\x01\x02\0\x03\x12\x04\xfa\x01\ + !\"\n\xb4\x03\n\x04\x04\t\x03\x02\x12\x06\x84\x02\x02\x91\x02\x03\x1a\ + \xa3\x03\x20A\x20RowFilter\x20which\x20evaluates\x20one\x20of\x20two\x20\ + possible\x20RowFilters,\x20depending\x20on\n\x20whether\x20or\x20not\x20\ + a\x20predicate\x20RowFilter\x20outputs\x20any\x20cells\x20from\x20the\ + \x20input\x20row.\n\n\x20IMPORTANT\x20NOTE:\x20The\x20predicate\x20filte\ + r\x20does\x20not\x20execute\x20atomically\x20with\x20the\n\x20true\x20an\ + d\x20false\x20filters,\x20which\x20may\x20lead\x20to\x20inconsistent\x20\ + or\x20unexpected\n\x20results.\x20Additionally,\x20Condition\x20filters\ + \x20have\x20poor\x20performance,\x20especially\n\x20when\x20filters\x20a\ + re\x20set\x20for\x20the\x20false\x20condition.\n\n\r\n\x05\x04\t\x03\x02\ + \x01\x12\x04\x84\x02\n\x13\n\xa0\x01\n\x06\x04\t\x03\x02\x02\0\x12\x04\ + \x87\x02\x04#\x1a\x8f\x01\x20If\x20`predicate_filter`\x20outputs\x20any\ + \x20cells,\x20then\x20`true_filter`\x20will\x20be\n\x20evaluated\x20on\ + \x20the\x20input\x20row.\x20Otherwise,\x20`false_filter`\x20will\x20be\ + \x20evaluated.\n\n\x11\n\x07\x04\t\x03\x02\x02\0\x04\x12\x06\x87\x02\x04\ + \x84\x02\x15\n\x0f\n\x07\x04\t\x03\x02\x02\0\x06\x12\x04\x87\x02\x04\r\n\ + \x0f\n\x07\x04\t\x03\x02\x02\0\x01\x12\x04\x87\x02\x0e\x1e\n\x0f\n\x07\ + \x04\t\x03\x02\x02\0\x03\x12\x04\x87\x02!\"\n\xa2\x01\n\x06\x04\t\x03\ + \x02\x02\x01\x12\x04\x8b\x02\x04\x1e\x1a\x91\x01\x20The\x20filter\x20to\ + \x20apply\x20to\x20the\x20input\x20row\x20if\x20`predicate_filter`\x20re\ + turns\x20any\n\x20results.\x20If\x20not\x20provided,\x20no\x20results\ + \x20will\x20be\x20returned\x20in\x20the\x20true\x20case.\n\n\x11\n\x07\ + \x04\t\x03\x02\x02\x01\x04\x12\x06\x8b\x02\x04\x87\x02#\n\x0f\n\x07\x04\ + \t\x03\x02\x02\x01\x06\x12\x04\x8b\x02\x04\r\n\x0f\n\x07\x04\t\x03\x02\ + \x02\x01\x01\x12\x04\x8b\x02\x0e\x19\n\x0f\n\x07\x04\t\x03\x02\x02\x01\ + \x03\x12\x04\x8b\x02\x1c\x1d\n\xac\x01\n\x06\x04\t\x03\x02\x02\x02\x12\ + \x04\x90\x02\x04\x1f\x1a\x9b\x01\x20The\x20filter\x20to\x20apply\x20to\ + \x20the\x20input\x20row\x20if\x20`predicate_filter`\x20does\x20not\n\x20\ + return\x20any\x20results.\x20If\x20not\x20provided,\x20no\x20results\x20\ + will\x20be\x20returned\x20in\x20the\n\x20false\x20case.\n\n\x11\n\x07\ + \x04\t\x03\x02\x02\x02\x04\x12\x06\x90\x02\x04\x8b\x02\x1e\n\x0f\n\x07\ + \x04\t\x03\x02\x02\x02\x06\x12\x04\x90\x02\x04\r\n\x0f\n\x07\x04\t\x03\ + \x02\x02\x02\x01\x12\x04\x90\x02\x0e\x1a\n\x0f\n\x07\x04\t\x03\x02\x02\ + \x02\x03\x12\x04\x90\x02\x1d\x1e\n\x86\x01\n\x04\x04\t\x08\0\x12\x06\x95\ + \x02\x02\xb7\x03\x03\x1av\x20Which\x20of\x20the\x20possible\x20RowFilter\ + \x20types\x20to\x20apply.\x20If\x20none\x20are\x20set,\x20this\n\x20RowF\ + ilter\x20returns\x20all\x20cells\x20in\x20the\x20input\x20row.\n\n\r\n\ + \x05\x04\t\x08\0\x01\x12\x04\x95\x02\x08\x0e\ni\n\x04\x04\t\x02\0\x12\ + \x04\x98\x02\x04\x14\x1a[\x20Applies\x20several\x20RowFilters\x20to\x20t\ + he\x20data\x20in\x20sequence,\x20progressively\n\x20narrowing\x20the\x20\ + results.\n\n\r\n\x05\x04\t\x02\0\x06\x12\x04\x98\x02\x04\t\n\r\n\x05\x04\ + \t\x02\0\x01\x12\x04\x98\x02\n\x0f\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x98\ + \x02\x12\x13\n]\n\x04\x04\t\x02\x01\x12\x04\x9c\x02\x04\x1e\x1aO\x20Appl\ + ies\x20several\x20RowFilters\x20to\x20the\x20data\x20in\x20parallel\x20a\ + nd\x20combines\x20the\n\x20results.\n\n\r\n\x05\x04\t\x02\x01\x06\x12\ + \x04\x9c\x02\x04\x0e\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\x9c\x02\x0f\x19\ + \n\r\n\x05\x04\t\x02\x01\x03\x12\x04\x9c\x02\x1c\x1d\nq\n\x04\x04\t\x02\ + \x02\x12\x04\xa0\x02\x04\x1c\x1ac\x20Applies\x20one\x20of\x20two\x20poss\ + ible\x20RowFilters\x20to\x20the\x20data\x20based\x20on\x20the\x20output\ + \x20of\n\x20a\x20predicate\x20RowFilter.\n\n\r\n\x05\x04\t\x02\x02\x06\ + \x12\x04\xa0\x02\x04\r\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xa0\x02\x0e\ + \x17\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xa0\x02\x1a\x1b\n\xb7\x14\n\x04\ + \x04\t\x02\x03\x12\x04\xdd\x02\x04\x13\x1a\xa8\x14\x20ADVANCED\x20USE\ + \x20ONLY.\n\x20Hook\x20for\x20introspection\x20into\x20the\x20RowFilter.\ + \x20Outputs\x20all\x20cells\x20directly\x20to\n\x20the\x20output\x20of\ + \x20the\x20read\x20rather\x20than\x20to\x20any\x20parent\x20filter.\x20C\ + onsider\x20the\n\x20following\x20example:\n\n\x20\x20\x20\x20\x20Chain(\ + \n\x20\x20\x20\x20\x20\x20\x20FamilyRegex(\"A\"),\n\x20\x20\x20\x20\x20\ + \x20\x20Interleave(\n\x20\x20\x20\x20\x20\x20\x20\x20\x20All(),\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20Chain(Label(\"foo\"),\x20Sink())\n\x20\ + \x20\x20\x20\x20\x20\x20),\n\x20\x20\x20\x20\x20\x20\x20QualifierRegex(\ + \"B\")\n\x20\x20\x20\x20\x20)\n\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,A,1,w\ + \n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + B,B,4,z\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20Fami\ + lyRegex(\"A\")\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20A,A,1,w\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20+------------+-------------+\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20All()\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20Label(foo)\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20A,A,1,w\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20A,A,1,w,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20A,B,2,x,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20Sink()\x20--------------+\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20+------------+\x20\ + \x20\x20\x20\x20\x20x------+\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,A,\ + 1,w,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20A,B,2,x,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,A,\ + 1,w\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20QualifierRegex(\"B\")\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + |\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20|\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20|\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20+-----------------------\ + ---------+\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20|\n\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20A,A,1,w,labels:[foo]\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20A,B,2,x,\ + labels:[foo]\x20\x20//\x20could\x20be\x20switched\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20A,B,2,x\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20//\x20could\x20be\x20switched\n\n\x20Despite\x20being\x20excluded\ + \x20by\x20the\x20qualifier\x20filter,\x20a\x20copy\x20of\x20every\x20cel\ + l\n\x20that\x20reaches\x20the\x20sink\x20is\x20present\x20in\x20the\x20f\ + inal\x20result.\n\n\x20As\x20with\x20an\x20[Interleave][google.bigtable.\ + v2.RowFilter.Interleave],\n\x20duplicate\x20cells\x20are\x20possible,\ + \x20and\x20appear\x20in\x20an\x20unspecified\x20mutual\x20order.\n\x20In\ + \x20this\x20case\x20we\x20have\x20a\x20duplicate\x20with\x20column\x20\"\ + A:B\"\x20and\x20timestamp\x202,\n\x20because\x20one\x20copy\x20passed\ + \x20through\x20the\x20all\x20filter\x20while\x20the\x20other\x20was\n\ + \x20passed\x20through\x20the\x20label\x20and\x20sink.\x20Note\x20that\ + \x20one\x20copy\x20has\x20label\x20\"foo\",\n\x20while\x20the\x20other\ + \x20does\x20not.\n\n\x20Cannot\x20be\x20used\x20within\x20the\x20`predic\ + ate_filter`,\x20`true_filter`,\x20or\n\x20`false_filter`\x20of\x20a\x20[\ + Condition][google.bigtable.v2.RowFilter.Condition].\n\n\r\n\x05\x04\t\ + \x02\x03\x05\x12\x04\xdd\x02\x04\x08\n\r\n\x05\x04\t\x02\x03\x01\x12\x04\ + \xdd\x02\t\r\n\r\n\x05\x04\t\x02\x03\x03\x12\x04\xdd\x02\x10\x12\n\x8a\ + \x01\n\x04\x04\t\x02\x04\x12\x04\xe1\x02\x04\x1e\x1a|\x20Matches\x20all\ + \x20cells,\x20regardless\x20of\x20input.\x20Functionally\x20equivalent\ + \x20to\n\x20leaving\x20`filter`\x20unset,\x20but\x20included\x20for\x20c\ + ompleteness.\n\n\r\n\x05\x04\t\x02\x04\x05\x12\x04\xe1\x02\x04\x08\n\r\n\ + \x05\x04\t\x02\x04\x01\x12\x04\xe1\x02\t\x18\n\r\n\x05\x04\t\x02\x04\x03\ + \x12\x04\xe1\x02\x1b\x1d\nw\n\x04\x04\t\x02\x05\x12\x04\xe5\x02\x04\x1f\ + \x1ai\x20Does\x20not\x20match\x20any\x20cells,\x20regardless\x20of\x20in\ + put.\x20Useful\x20for\x20temporarily\n\x20disabling\x20just\x20part\x20o\ + f\x20a\x20filter.\n\n\r\n\x05\x04\t\x02\x05\x05\x12\x04\xe5\x02\x04\x08\ + \n\r\n\x05\x04\t\x02\x05\x01\x12\x04\xe5\x02\t\x19\n\r\n\x05\x04\t\x02\ + \x05\x03\x12\x04\xe5\x02\x1c\x1e\n\xa4\x03\n\x04\x04\t\x02\x06\x12\x04\ + \xee\x02\x04#\x1a\x95\x03\x20Matches\x20only\x20cells\x20from\x20rows\ + \x20whose\x20keys\x20satisfy\x20the\x20given\x20RE2\x20regex.\x20In\n\ + \x20other\x20words,\x20passes\x20through\x20the\x20entire\x20row\x20when\ + \x20the\x20key\x20matches,\x20and\n\x20otherwise\x20produces\x20an\x20em\ + pty\x20row.\n\x20Note\x20that,\x20since\x20row\x20keys\x20can\x20contain\ + \x20arbitrary\x20bytes,\x20the\x20`\\C`\x20escape\n\x20sequence\x20must\ + \x20be\x20used\x20if\x20a\x20true\x20wildcard\x20is\x20desired.\x20The\ + \x20`.`\x20character\n\x20will\x20not\x20match\x20the\x20new\x20line\x20\ + character\x20`\\n`,\x20which\x20may\x20be\x20present\x20in\x20a\n\x20bin\ + ary\x20key.\n\n\r\n\x05\x04\t\x02\x06\x05\x12\x04\xee\x02\x04\t\n\r\n\ + \x05\x04\t\x02\x06\x01\x12\x04\xee\x02\n\x1e\n\r\n\x05\x04\t\x02\x06\x03\ + \x12\x04\xee\x02!\"\ny\n\x04\x04\t\x02\x07\x12\x04\xf2\x02\x04\"\x1ak\ + \x20Matches\x20all\x20cells\x20from\x20a\x20row\x20with\x20probability\ + \x20p,\x20and\x20matches\x20no\x20cells\n\x20from\x20the\x20row\x20with\ + \x20probability\x201-p.\n\n\r\n\x05\x04\t\x02\x07\x05\x12\x04\xf2\x02\ + \x04\n\n\r\n\x05\x04\t\x02\x07\x01\x12\x04\xf2\x02\x0b\x1c\n\r\n\x05\x04\ + \t\x02\x07\x03\x12\x04\xf2\x02\x1f!\n\xf0\x02\n\x04\x04\t\x02\x08\x12\ + \x04\xfa\x02\x04(\x1a\xe1\x02\x20Matches\x20only\x20cells\x20from\x20col\ + umns\x20whose\x20families\x20satisfy\x20the\x20given\x20RE2\n\x20regex.\ + \x20For\x20technical\x20reasons,\x20the\x20regex\x20must\x20not\x20conta\ + in\x20the\x20`:`\n\x20character,\x20even\x20if\x20it\x20is\x20not\x20bei\ + ng\x20used\x20as\x20a\x20literal.\n\x20Note\x20that,\x20since\x20column\ + \x20families\x20cannot\x20contain\x20the\x20new\x20line\x20character\n\ + \x20`\\n`,\x20it\x20is\x20sufficient\x20to\x20use\x20`.`\x20as\x20a\x20f\ + ull\x20wildcard\x20when\x20matching\n\x20column\x20family\x20names.\n\n\ + \r\n\x05\x04\t\x02\x08\x05\x12\x04\xfa\x02\x04\n\n\r\n\x05\x04\t\x02\x08\ + \x01\x12\x04\xfa\x02\x0b#\n\r\n\x05\x04\t\x02\x08\x03\x12\x04\xfa\x02&'\ + \n\xd2\x02\n\x04\x04\t\x02\t\x12\x04\x82\x03\x04,\x1a\xc3\x02\x20Matches\ + \x20only\x20cells\x20from\x20columns\x20whose\x20qualifiers\x20satisfy\ + \x20the\x20given\x20RE2\n\x20regex.\n\x20Note\x20that,\x20since\x20colum\ + n\x20qualifiers\x20can\x20contain\x20arbitrary\x20bytes,\x20the\x20`\\C`\ + \n\x20escape\x20sequence\x20must\x20be\x20used\x20if\x20a\x20true\x20wil\ + dcard\x20is\x20desired.\x20The\x20`.`\n\x20character\x20will\x20not\x20m\ + atch\x20the\x20new\x20line\x20character\x20`\\n`,\x20which\x20may\x20be\ + \n\x20present\x20in\x20a\x20binary\x20qualifier.\n\n\r\n\x05\x04\t\x02\t\ + \x05\x12\x04\x82\x03\x04\t\n\r\n\x05\x04\t\x02\t\x01\x12\x04\x82\x03\n'\ + \n\r\n\x05\x04\t\x02\t\x03\x12\x04\x82\x03*+\nG\n\x04\x04\t\x02\n\x12\ + \x04\x85\x03\x04(\x1a9\x20Matches\x20only\x20cells\x20from\x20columns\ + \x20within\x20the\x20given\x20range.\n\n\r\n\x05\x04\t\x02\n\x06\x12\x04\ + \x85\x03\x04\x0f\n\r\n\x05\x04\t\x02\n\x01\x12\x04\x85\x03\x10#\n\r\n\ + \x05\x04\t\x02\n\x03\x12\x04\x85\x03&'\nJ\n\x04\x04\t\x02\x0b\x12\x04\ + \x88\x03\x04.\x1a<\x20Matches\x20only\x20cells\x20with\x20timestamps\x20\ + within\x20the\x20given\x20range.\n\n\r\n\x05\x04\t\x02\x0b\x06\x12\x04\ + \x88\x03\x04\x12\n\r\n\x05\x04\t\x02\x0b\x01\x12\x04\x88\x03\x13)\n\r\n\ + \x05\x04\t\x02\x0b\x03\x12\x04\x88\x03,-\n\xc3\x02\n\x04\x04\t\x02\x0c\ + \x12\x04\x8f\x03\x04!\x1a\xb4\x02\x20Matches\x20only\x20cells\x20with\ + \x20values\x20that\x20satisfy\x20the\x20given\x20regular\x20expression.\ + \n\x20Note\x20that,\x20since\x20cell\x20values\x20can\x20contain\x20arbi\ + trary\x20bytes,\x20the\x20`\\C`\x20escape\n\x20sequence\x20must\x20be\ + \x20used\x20if\x20a\x20true\x20wildcard\x20is\x20desired.\x20The\x20`.`\ + \x20character\n\x20will\x20not\x20match\x20the\x20new\x20line\x20charact\ + er\x20`\\n`,\x20which\x20may\x20be\x20present\x20in\x20a\n\x20binary\x20\ + value.\n\n\r\n\x05\x04\t\x02\x0c\x05\x12\x04\x8f\x03\x04\t\n\r\n\x05\x04\ + \t\x02\x0c\x01\x12\x04\x8f\x03\n\x1c\n\r\n\x05\x04\t\x02\x0c\x03\x12\x04\ + \x8f\x03\x1f\x20\nP\n\x04\x04\t\x02\r\x12\x04\x92\x03\x04'\x1aB\x20Match\ + es\x20only\x20cells\x20with\x20values\x20that\x20fall\x20within\x20the\ + \x20given\x20range.\n\n\r\n\x05\x04\t\x02\r\x06\x12\x04\x92\x03\x04\x0e\ + \n\r\n\x05\x04\t\x02\r\x01\x12\x04\x92\x03\x0f!\n\r\n\x05\x04\t\x02\r\ + \x03\x12\x04\x92\x03$&\n\xcc\x01\n\x04\x04\t\x02\x0e\x12\x04\x97\x03\x04\ + +\x1a\xbd\x01\x20Skips\x20the\x20first\x20N\x20cells\x20of\x20each\x20ro\ + w,\x20matching\x20all\x20subsequent\x20cells.\n\x20If\x20duplicate\x20ce\ + lls\x20are\x20present,\x20as\x20is\x20possible\x20when\x20using\x20an\ + \x20Interleave,\n\x20each\x20copy\x20of\x20the\x20cell\x20is\x20counted\ + \x20separately.\n\n\r\n\x05\x04\t\x02\x0e\x05\x12\x04\x97\x03\x04\t\n\r\ + \n\x05\x04\t\x02\x0e\x01\x12\x04\x97\x03\n%\n\r\n\x05\x04\t\x02\x0e\x03\ + \x12\x04\x97\x03(*\n\xb4\x01\n\x04\x04\t\x02\x0f\x12\x04\x9c\x03\x04*\ + \x1a\xa5\x01\x20Matches\x20only\x20the\x20first\x20N\x20cells\x20of\x20e\ + ach\x20row.\n\x20If\x20duplicate\x20cells\x20are\x20present,\x20as\x20is\ + \x20possible\x20when\x20using\x20an\x20Interleave,\n\x20each\x20copy\x20\ + of\x20the\x20cell\x20is\x20counted\x20separately.\n\n\r\n\x05\x04\t\x02\ + \x0f\x05\x12\x04\x9c\x03\x04\t\n\r\n\x05\x04\t\x02\x0f\x01\x12\x04\x9c\ + \x03\n$\n\r\n\x05\x04\t\x02\x0f\x03\x12\x04\x9c\x03')\n\xf3\x02\n\x04\ + \x04\t\x02\x10\x12\x04\xa4\x03\x04-\x1a\xe4\x02\x20Matches\x20only\x20th\ + e\x20most\x20recent\x20N\x20cells\x20within\x20each\x20column.\x20For\ + \x20example,\n\x20if\x20N=2,\x20this\x20filter\x20would\x20match\x20colu\ + mn\x20`foo:bar`\x20at\x20timestamps\x2010\x20and\x209,\n\x20skip\x20all\ + \x20earlier\x20cells\x20in\x20`foo:bar`,\x20and\x20then\x20begin\x20matc\ + hing\x20again\x20in\n\x20column\x20`foo:bar2`.\n\x20If\x20duplicate\x20c\ + ells\x20are\x20present,\x20as\x20is\x20possible\x20when\x20using\x20an\ + \x20Interleave,\n\x20each\x20copy\x20of\x20the\x20cell\x20is\x20counted\ + \x20separately.\n\n\r\n\x05\x04\t\x02\x10\x05\x12\x04\xa4\x03\x04\t\n\r\ + \n\x05\x04\t\x02\x10\x01\x12\x04\xa4\x03\n'\n\r\n\x05\x04\t\x02\x10\x03\ + \x12\x04\xa4\x03*,\nA\n\x04\x04\t\x02\x11\x12\x04\xa7\x03\x04&\x1a3\x20R\ + eplaces\x20each\x20cell's\x20value\x20with\x20the\x20empty\x20string.\n\ + \n\r\n\x05\x04\t\x02\x11\x05\x12\x04\xa7\x03\x04\x08\n\r\n\x05\x04\t\x02\ + \x11\x01\x12\x04\xa7\x03\t\x20\n\r\n\x05\x04\t\x02\x11\x03\x12\x04\xa7\ + \x03#%\n\xfb\x04\n\x04\x04\t\x02\x12\x12\x04\xb6\x03\x04(\x1a\xec\x04\ + \x20Applies\x20the\x20given\x20label\x20to\x20all\x20cells\x20in\x20the\ + \x20output\x20row.\x20This\x20allows\n\x20the\x20client\x20to\x20determi\ + ne\x20which\x20results\x20were\x20produced\x20from\x20which\x20part\x20o\ + f\n\x20the\x20filter.\n\n\x20Values\x20must\x20be\x20at\x20most\x2015\ + \x20characters\x20in\x20length,\x20and\x20match\x20the\x20RE2\n\x20patte\ + rn\x20`[a-z0-9\\\\-]+`\n\n\x20Due\x20to\x20a\x20technical\x20limitation,\ + \x20it\x20is\x20not\x20currently\x20possible\x20to\x20apply\n\x20multipl\ + e\x20labels\x20to\x20a\x20cell.\x20As\x20a\x20result,\x20a\x20Chain\x20m\ + ay\x20have\x20no\x20more\x20than\n\x20one\x20sub-filter\x20which\x20cont\ + ains\x20a\x20`apply_label_transformer`.\x20It\x20is\x20okay\x20for\n\x20\ + an\x20Interleave\x20to\x20contain\x20multiple\x20`apply_label_transforme\ + rs`,\x20as\x20they\n\x20will\x20be\x20applied\x20to\x20separate\x20copie\ + s\x20of\x20the\x20input.\x20This\x20may\x20be\x20relaxed\x20in\n\x20the\ + \x20future.\n\n\r\n\x05\x04\t\x02\x12\x05\x12\x04\xb6\x03\x04\n\n\r\n\ + \x05\x04\t\x02\x12\x01\x12\x04\xb6\x03\x0b\"\n\r\n\x05\x04\t\x02\x12\x03\ + \x12\x04\xb6\x03%'\nR\n\x02\x04\n\x12\x06\xbb\x03\0\xfa\x03\x01\x1aD\x20\ + Specifies\x20a\x20particular\x20change\x20to\x20be\x20made\x20to\x20the\ + \x20contents\x20of\x20a\x20row.\n\n\x0b\n\x03\x04\n\x01\x12\x04\xbb\x03\ + \x08\x10\nH\n\x04\x04\n\x03\0\x12\x06\xbd\x03\x02\xcf\x03\x03\x1a8\x20A\ + \x20Mutation\x20which\x20sets\x20the\x20value\x20of\x20the\x20specified\ + \x20cell.\n\n\r\n\x05\x04\n\x03\0\x01\x12\x04\xbd\x03\n\x11\nm\n\x06\x04\ + \n\x03\0\x02\0\x12\x04\xc0\x03\x04\x1b\x1a]\x20The\x20name\x20of\x20the\ + \x20family\x20into\x20which\x20new\x20data\x20should\x20be\x20written.\n\ + \x20Must\x20match\x20`[-_.a-zA-Z0-9]+`\n\n\x11\n\x07\x04\n\x03\0\x02\0\ + \x04\x12\x06\xc0\x03\x04\xbd\x03\x13\n\x0f\n\x07\x04\n\x03\0\x02\0\x05\ + \x12\x04\xc0\x03\x04\n\n\x0f\n\x07\x04\n\x03\0\x02\0\x01\x12\x04\xc0\x03\ + \x0b\x16\n\x0f\n\x07\x04\n\x03\0\x02\0\x03\x12\x04\xc0\x03\x19\x1a\n\x89\ + \x01\n\x06\x04\n\x03\0\x02\x01\x12\x04\xc4\x03\x04\x1f\x1ay\x20The\x20qu\ + alifier\x20of\x20the\x20column\x20into\x20which\x20new\x20data\x20should\ + \x20be\x20written.\n\x20Can\x20be\x20any\x20byte\x20string,\x20including\ + \x20the\x20empty\x20string.\n\n\x11\n\x07\x04\n\x03\0\x02\x01\x04\x12\ + \x06\xc4\x03\x04\xc0\x03\x1b\n\x0f\n\x07\x04\n\x03\0\x02\x01\x05\x12\x04\ + \xc4\x03\x04\t\n\x0f\n\x07\x04\n\x03\0\x02\x01\x01\x12\x04\xc4\x03\n\x1a\ + \n\x0f\n\x07\x04\n\x03\0\x02\x01\x03\x12\x04\xc4\x03\x1d\x1e\n\xd1\x02\n\ + \x06\x04\n\x03\0\x02\x02\x12\x04\xcb\x03\x04\x1f\x1a\xc0\x02\x20The\x20t\ + imestamp\x20of\x20the\x20cell\x20into\x20which\x20new\x20data\x20should\ + \x20be\x20written.\n\x20Use\x20-1\x20for\x20current\x20Bigtable\x20serve\ + r\x20time.\n\x20Otherwise,\x20the\x20client\x20should\x20set\x20this\x20\ + value\x20itself,\x20noting\x20that\x20the\n\x20default\x20value\x20is\ + \x20a\x20timestamp\x20of\x20zero\x20if\x20the\x20field\x20is\x20left\x20\ + unspecified.\n\x20Values\x20must\x20match\x20the\x20granularity\x20of\ + \x20the\x20table\x20(e.g.\x20micros,\x20millis).\n\n\x11\n\x07\x04\n\x03\ + \0\x02\x02\x04\x12\x06\xcb\x03\x04\xc4\x03\x1f\n\x0f\n\x07\x04\n\x03\0\ + \x02\x02\x05\x12\x04\xcb\x03\x04\t\n\x0f\n\x07\x04\n\x03\0\x02\x02\x01\ + \x12\x04\xcb\x03\n\x1a\n\x0f\n\x07\x04\n\x03\0\x02\x02\x03\x12\x04\xcb\ + \x03\x1d\x1e\nB\n\x06\x04\n\x03\0\x02\x03\x12\x04\xce\x03\x04\x14\x1a2\ + \x20The\x20value\x20to\x20be\x20written\x20into\x20the\x20specified\x20c\ + ell.\n\n\x11\n\x07\x04\n\x03\0\x02\x03\x04\x12\x06\xce\x03\x04\xcb\x03\ + \x1f\n\x0f\n\x07\x04\n\x03\0\x02\x03\x05\x12\x04\xce\x03\x04\t\n\x0f\n\ + \x07\x04\n\x03\0\x02\x03\x01\x12\x04\xce\x03\n\x0f\n\x0f\n\x07\x04\n\x03\ + \0\x02\x03\x03\x12\x04\xce\x03\x12\x13\n\x8d\x01\n\x04\x04\n\x03\x01\x12\ + \x06\xd3\x03\x02\xde\x03\x03\x1a}\x20A\x20Mutation\x20which\x20deletes\ + \x20cells\x20from\x20the\x20specified\x20column,\x20optionally\n\x20rest\ + ricting\x20the\x20deletions\x20to\x20a\x20given\x20timestamp\x20range.\n\ + \n\r\n\x05\x04\n\x03\x01\x01\x12\x04\xd3\x03\n\x1a\nj\n\x06\x04\n\x03\ + \x01\x02\0\x12\x04\xd6\x03\x04\x1b\x1aZ\x20The\x20name\x20of\x20the\x20f\ + amily\x20from\x20which\x20cells\x20should\x20be\x20deleted.\n\x20Must\ + \x20match\x20`[-_.a-zA-Z0-9]+`\n\n\x11\n\x07\x04\n\x03\x01\x02\0\x04\x12\ + \x06\xd6\x03\x04\xd3\x03\x1c\n\x0f\n\x07\x04\n\x03\x01\x02\0\x05\x12\x04\ + \xd6\x03\x04\n\n\x0f\n\x07\x04\n\x03\x01\x02\0\x01\x12\x04\xd6\x03\x0b\ + \x16\n\x0f\n\x07\x04\n\x03\x01\x02\0\x03\x12\x04\xd6\x03\x19\x1a\n\x86\ + \x01\n\x06\x04\n\x03\x01\x02\x01\x12\x04\xda\x03\x04\x1f\x1av\x20The\x20\ + qualifier\x20of\x20the\x20column\x20from\x20which\x20cells\x20should\x20\ + be\x20deleted.\n\x20Can\x20be\x20any\x20byte\x20string,\x20including\x20\ + the\x20empty\x20string.\n\n\x11\n\x07\x04\n\x03\x01\x02\x01\x04\x12\x06\ + \xda\x03\x04\xd6\x03\x1b\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x05\x12\x04\ + \xda\x03\x04\t\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x01\x12\x04\xda\x03\n\ + \x1a\n\x0f\n\x07\x04\n\x03\x01\x02\x01\x03\x12\x04\xda\x03\x1d\x1e\nO\n\ + \x06\x04\n\x03\x01\x02\x02\x12\x04\xdd\x03\x04\"\x1a?\x20The\x20range\ + \x20of\x20timestamps\x20within\x20which\x20cells\x20should\x20be\x20dele\ + ted.\n\n\x11\n\x07\x04\n\x03\x01\x02\x02\x04\x12\x06\xdd\x03\x04\xda\x03\ + \x1f\n\x0f\n\x07\x04\n\x03\x01\x02\x02\x06\x12\x04\xdd\x03\x04\x12\n\x0f\ + \n\x07\x04\n\x03\x01\x02\x02\x01\x12\x04\xdd\x03\x13\x1d\n\x0f\n\x07\x04\ + \n\x03\x01\x02\x02\x03\x12\x04\xdd\x03\x20!\nV\n\x04\x04\n\x03\x02\x12\ + \x06\xe1\x03\x02\xe5\x03\x03\x1aF\x20A\x20Mutation\x20which\x20deletes\ + \x20all\x20cells\x20from\x20the\x20specified\x20column\x20family.\n\n\r\ + \n\x05\x04\n\x03\x02\x01\x12\x04\xe1\x03\n\x1a\nj\n\x06\x04\n\x03\x02\ + \x02\0\x12\x04\xe4\x03\x04\x1b\x1aZ\x20The\x20name\x20of\x20the\x20famil\ + y\x20from\x20which\x20cells\x20should\x20be\x20deleted.\n\x20Must\x20mat\ + ch\x20`[-_.a-zA-Z0-9]+`\n\n\x11\n\x07\x04\n\x03\x02\x02\0\x04\x12\x06\ + \xe4\x03\x04\xe1\x03\x1c\n\x0f\n\x07\x04\n\x03\x02\x02\0\x05\x12\x04\xe4\ + \x03\x04\n\n\x0f\n\x07\x04\n\x03\x02\x02\0\x01\x12\x04\xe4\x03\x0b\x16\n\ + \x0f\n\x07\x04\n\x03\x02\x02\0\x03\x12\x04\xe4\x03\x19\x1a\nM\n\x04\x04\ + \n\x03\x03\x12\x06\xe8\x03\x02\xea\x03\x03\x1a=\x20A\x20Mutation\x20whic\ + h\x20deletes\x20all\x20cells\x20from\x20the\x20containing\x20row.\n\n\r\ + \n\x05\x04\n\x03\x03\x01\x12\x04\xe8\x03\n\x17\n@\n\x04\x04\n\x08\0\x12\ + \x06\xed\x03\x02\xf9\x03\x03\x1a0\x20Which\x20of\x20the\x20possible\x20M\ + utation\x20types\x20to\x20apply.\n\n\r\n\x05\x04\n\x08\0\x01\x12\x04\xed\ + \x03\x08\x10\n#\n\x04\x04\n\x02\0\x12\x04\xef\x03\x04\x19\x1a\x15\x20Set\ + \x20a\x20cell's\x20value.\n\n\r\n\x05\x04\n\x02\0\x06\x12\x04\xef\x03\ + \x04\x0b\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xef\x03\x0c\x14\n\r\n\x05\x04\ + \n\x02\0\x03\x12\x04\xef\x03\x17\x18\n,\n\x04\x04\n\x02\x01\x12\x04\xf2\ + \x03\x04,\x1a\x1e\x20Deletes\x20cells\x20from\x20a\x20column.\n\n\r\n\ + \x05\x04\n\x02\x01\x06\x12\x04\xf2\x03\x04\x14\n\r\n\x05\x04\n\x02\x01\ + \x01\x12\x04\xf2\x03\x15'\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xf2\x03*+\ + \n3\n\x04\x04\n\x02\x02\x12\x04\xf5\x03\x04,\x1a%\x20Deletes\x20cells\ + \x20from\x20a\x20column\x20family.\n\n\r\n\x05\x04\n\x02\x02\x06\x12\x04\ + \xf5\x03\x04\x14\n\r\n\x05\x04\n\x02\x02\x01\x12\x04\xf5\x03\x15'\n\r\n\ + \x05\x04\n\x02\x02\x03\x12\x04\xf5\x03*+\n2\n\x04\x04\n\x02\x03\x12\x04\ + \xf8\x03\x04&\x1a$\x20Deletes\x20cells\x20from\x20the\x20entire\x20row.\ + \n\n\r\n\x05\x04\n\x02\x03\x06\x12\x04\xf8\x03\x04\x11\n\r\n\x05\x04\n\ + \x02\x03\x01\x12\x04\xf8\x03\x12!\n\r\n\x05\x04\n\x02\x03\x03\x12\x04\ + \xf8\x03$%\nm\n\x02\x04\x0b\x12\x06\xfe\x03\0\x96\x04\x01\x1a_\x20Specif\ + ies\x20an\x20atomic\x20read/modify/write\x20operation\x20on\x20the\x20la\ + test\x20value\x20of\x20the\n\x20specified\x20column.\n\n\x0b\n\x03\x04\ + \x0b\x01\x12\x04\xfe\x03\x08\x1b\nv\n\x04\x04\x0b\x02\0\x12\x04\x81\x04\ + \x02\x19\x1ah\x20The\x20name\x20of\x20the\x20family\x20to\x20which\x20th\ + e\x20read/modify/write\x20should\x20be\x20applied.\n\x20Must\x20match\ + \x20`[-_.a-zA-Z0-9]+`\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\x81\x04\ + \x02\xfe\x03\x1d\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\x81\x04\x02\x08\n\r\ + \n\x05\x04\x0b\x02\0\x01\x12\x04\x81\x04\t\x14\n\r\n\x05\x04\x0b\x02\0\ + \x03\x12\x04\x81\x04\x17\x18\n\x94\x01\n\x04\x04\x0b\x02\x01\x12\x04\x86\ + \x04\x02\x1d\x1a\x85\x01\x20The\x20qualifier\x20of\x20the\x20column\x20t\ + o\x20which\x20the\x20read/modify/write\x20should\x20be\n\x20applied.\n\ + \x20Can\x20be\x20any\x20byte\x20string,\x20including\x20the\x20empty\x20\ + string.\n\n\x0f\n\x05\x04\x0b\x02\x01\x04\x12\x06\x86\x04\x02\x81\x04\ + \x19\n\r\n\x05\x04\x0b\x02\x01\x05\x12\x04\x86\x04\x02\x07\n\r\n\x05\x04\ + \x0b\x02\x01\x01\x12\x04\x86\x04\x08\x18\n\r\n\x05\x04\x0b\x02\x01\x03\ + \x12\x04\x86\x04\x1b\x1c\nj\n\x04\x04\x0b\x08\0\x12\x06\x8a\x04\x02\x95\ + \x04\x03\x1aZ\x20The\x20rule\x20used\x20to\x20determine\x20the\x20column\ + 's\x20new\x20latest\x20value\x20from\x20its\x20current\n\x20latest\x20va\ + lue.\n\n\r\n\x05\x04\x0b\x08\0\x01\x12\x04\x8a\x04\x08\x0c\n\xab\x01\n\ + \x04\x04\x0b\x02\x02\x12\x04\x8e\x04\x04\x1b\x1a\x9c\x01\x20Rule\x20spec\ + ifying\x20that\x20`append_value`\x20be\x20appended\x20to\x20the\x20exist\ + ing\x20value.\n\x20If\x20the\x20targeted\x20cell\x20is\x20unset,\x20it\ + \x20will\x20be\x20treated\x20as\x20containing\x20the\n\x20empty\x20strin\ + g.\n\n\r\n\x05\x04\x0b\x02\x02\x05\x12\x04\x8e\x04\x04\t\n\r\n\x05\x04\ + \x0b\x02\x02\x01\x12\x04\x8e\x04\n\x16\n\r\n\x05\x04\x0b\x02\x02\x03\x12\ + \x04\x8e\x04\x19\x1a\n\xb3\x02\n\x04\x04\x0b\x02\x03\x12\x04\x94\x04\x04\ + \x1f\x1a\xa4\x02\x20Rule\x20specifying\x20that\x20`increment_amount`\x20\ + be\x20added\x20to\x20the\x20existing\x20value.\n\x20If\x20the\x20targete\ + d\x20cell\x20is\x20unset,\x20it\x20will\x20be\x20treated\x20as\x20contai\ + ning\x20a\x20zero.\n\x20Otherwise,\x20the\x20targeted\x20cell\x20must\ + \x20contain\x20an\x208-byte\x20value\x20(interpreted\n\x20as\x20a\x2064-\ + bit\x20big-endian\x20signed\x20integer),\x20or\x20the\x20entire\x20reque\ + st\x20will\x20fail.\n\n\r\n\x05\x04\x0b\x02\x03\x05\x12\x04\x94\x04\x04\ + \t\n\r\n\x05\x04\x0b\x02\x03\x01\x12\x04\x94\x04\n\x1a\n\r\n\x05\x04\x0b\ + \x02\x03\x03\x12\x04\x94\x04\x1d\x1eb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/mod.rs new file mode 100644 index 00000000..329fc131 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/bigtable/v2/mod.rs @@ -0,0 +1,5 @@ +pub mod bigtable; +pub mod bigtable_grpc; +pub mod data; + +pub(crate) use crate::rpc::status; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/empty.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/empty.rs new file mode 100644 index 00000000..ef3ae974 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/empty.rs @@ -0,0 +1,196 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `empty.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Empty { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Empty { + fn default() -> &'a Empty { + ::default_instance() + } +} + +impl Empty { + pub fn new() -> Empty { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for Empty { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Empty { + Empty::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "Empty", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Empty { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Empty, + }; + unsafe { + instance.get(Empty::new) + } + } +} + +impl ::protobuf::Clear for Empty { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Empty { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Empty { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x0bempty.proto\x12\x0cgrpc.testing\"\x07\n\x05EmptyJ\x90\x07\n\x06\ + \x12\x04\x0f\0\x1b\x10\n\xbf\x04\n\x01\x0c\x12\x03\x0f\0\x122\xb4\x04\ + \x20Copyright\x202015\x20gRPC\x20authors.\n\n\x20Licensed\x20under\x20th\ + e\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20\ + you\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20compliance\ + \x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\ + \x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/li\ + censes/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\ + \x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\ + \x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20\ + IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20A\ + NY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20Li\ + cense\x20for\x20the\x20specific\x20language\x20governing\x20permissions\ + \x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\ + \x12\x03\x11\0\x15\n\xad\x02\n\x02\x04\0\x12\x03\x1b\0\x10\x1a\xa1\x02\ + \x20An\x20empty\x20message\x20that\x20you\x20can\x20re-use\x20to\x20avoi\ + d\x20defining\x20duplicated\x20empty\n\x20messages\x20in\x20your\x20proj\ + ect.\x20A\x20typical\x20example\x20is\x20to\x20use\x20it\x20as\x20argume\ + nt\x20or\x20the\n\x20return\x20value\x20of\x20a\x20service\x20API.\x20Fo\ + r\x20instance:\n\n\x20\x20\x20service\x20Foo\x20{\n\x20\x20\x20\x20\x20r\ + pc\x20Bar\x20(grpc.testing.Empty)\x20returns\x20(grpc.testing.Empty)\x20\ + {\x20};\n\x20\x20\x20};\n\n\n\n\n\x03\x04\0\x01\x12\x03\x1b\x08\rb\x06pr\ + oto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/mod.rs new file mode 100644 index 00000000..a3a6d96c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy.rs new file mode 100644 index 00000000..00d0203c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy.rs @@ -0,0 +1,951 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/iam/v1/iam_policy.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct SetIamPolicyRequest { + // message fields + pub resource: ::std::string::String, + pub policy: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SetIamPolicyRequest { + fn default() -> &'a SetIamPolicyRequest { + ::default_instance() + } +} + +impl SetIamPolicyRequest { + pub fn new() -> SetIamPolicyRequest { + ::std::default::Default::default() + } + + // string resource = 1; + + + pub fn get_resource(&self) -> &str { + &self.resource + } + pub fn clear_resource(&mut self) { + self.resource.clear(); + } + + // Param is passed by value, moved + pub fn set_resource(&mut self, v: ::std::string::String) { + self.resource = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resource(&mut self) -> &mut ::std::string::String { + &mut self.resource + } + + // Take field + pub fn take_resource(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.resource, ::std::string::String::new()) + } + + // .google.iam.v1.Policy policy = 2; + + + pub fn get_policy(&self) -> &super::policy::Policy { + self.policy.as_ref().unwrap_or_else(|| super::policy::Policy::default_instance()) + } + pub fn clear_policy(&mut self) { + self.policy.clear(); + } + + pub fn has_policy(&self) -> bool { + self.policy.is_some() + } + + // Param is passed by value, moved + pub fn set_policy(&mut self, v: super::policy::Policy) { + self.policy = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_policy(&mut self) -> &mut super::policy::Policy { + if self.policy.is_none() { + self.policy.set_default(); + } + self.policy.as_mut().unwrap() + } + + // Take field + pub fn take_policy(&mut self) -> super::policy::Policy { + self.policy.take().unwrap_or_else(|| super::policy::Policy::new()) + } +} + +impl ::protobuf::Message for SetIamPolicyRequest { + fn is_initialized(&self) -> bool { + for v in &self.policy { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resource)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.policy)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.resource.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.resource); + } + if let Some(ref v) = self.policy.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.resource.is_empty() { + os.write_string(1, &self.resource)?; + } + if let Some(ref v) = self.policy.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SetIamPolicyRequest { + SetIamPolicyRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "resource", + |m: &SetIamPolicyRequest| { &m.resource }, + |m: &mut SetIamPolicyRequest| { &mut m.resource }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "policy", + |m: &SetIamPolicyRequest| { &m.policy }, + |m: &mut SetIamPolicyRequest| { &mut m.policy }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SetIamPolicyRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SetIamPolicyRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SetIamPolicyRequest, + }; + unsafe { + instance.get(SetIamPolicyRequest::new) + } + } +} + +impl ::protobuf::Clear for SetIamPolicyRequest { + fn clear(&mut self) { + self.resource.clear(); + self.policy.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SetIamPolicyRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SetIamPolicyRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetIamPolicyRequest { + // message fields + pub resource: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetIamPolicyRequest { + fn default() -> &'a GetIamPolicyRequest { + ::default_instance() + } +} + +impl GetIamPolicyRequest { + pub fn new() -> GetIamPolicyRequest { + ::std::default::Default::default() + } + + // string resource = 1; + + + pub fn get_resource(&self) -> &str { + &self.resource + } + pub fn clear_resource(&mut self) { + self.resource.clear(); + } + + // Param is passed by value, moved + pub fn set_resource(&mut self, v: ::std::string::String) { + self.resource = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resource(&mut self) -> &mut ::std::string::String { + &mut self.resource + } + + // Take field + pub fn take_resource(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.resource, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetIamPolicyRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resource)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.resource.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.resource); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.resource.is_empty() { + os.write_string(1, &self.resource)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetIamPolicyRequest { + GetIamPolicyRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "resource", + |m: &GetIamPolicyRequest| { &m.resource }, + |m: &mut GetIamPolicyRequest| { &mut m.resource }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetIamPolicyRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetIamPolicyRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetIamPolicyRequest, + }; + unsafe { + instance.get(GetIamPolicyRequest::new) + } + } +} + +impl ::protobuf::Clear for GetIamPolicyRequest { + fn clear(&mut self) { + self.resource.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetIamPolicyRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetIamPolicyRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TestIamPermissionsRequest { + // message fields + pub resource: ::std::string::String, + pub permissions: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TestIamPermissionsRequest { + fn default() -> &'a TestIamPermissionsRequest { + ::default_instance() + } +} + +impl TestIamPermissionsRequest { + pub fn new() -> TestIamPermissionsRequest { + ::std::default::Default::default() + } + + // string resource = 1; + + + pub fn get_resource(&self) -> &str { + &self.resource + } + pub fn clear_resource(&mut self) { + self.resource.clear(); + } + + // Param is passed by value, moved + pub fn set_resource(&mut self, v: ::std::string::String) { + self.resource = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resource(&mut self) -> &mut ::std::string::String { + &mut self.resource + } + + // Take field + pub fn take_resource(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.resource, ::std::string::String::new()) + } + + // repeated string permissions = 2; + + + pub fn get_permissions(&self) -> &[::std::string::String] { + &self.permissions + } + pub fn clear_permissions(&mut self) { + self.permissions.clear(); + } + + // Param is passed by value, moved + pub fn set_permissions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.permissions = v; + } + + // Mutable pointer to the field. + pub fn mut_permissions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.permissions + } + + // Take field + pub fn take_permissions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.permissions, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for TestIamPermissionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resource)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.permissions)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.resource.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.resource); + } + for value in &self.permissions { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.resource.is_empty() { + os.write_string(1, &self.resource)?; + } + for v in &self.permissions { + os.write_string(2, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TestIamPermissionsRequest { + TestIamPermissionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "resource", + |m: &TestIamPermissionsRequest| { &m.resource }, + |m: &mut TestIamPermissionsRequest| { &mut m.resource }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "permissions", + |m: &TestIamPermissionsRequest| { &m.permissions }, + |m: &mut TestIamPermissionsRequest| { &mut m.permissions }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TestIamPermissionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TestIamPermissionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TestIamPermissionsRequest, + }; + unsafe { + instance.get(TestIamPermissionsRequest::new) + } + } +} + +impl ::protobuf::Clear for TestIamPermissionsRequest { + fn clear(&mut self) { + self.resource.clear(); + self.permissions.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TestIamPermissionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TestIamPermissionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TestIamPermissionsResponse { + // message fields + pub permissions: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TestIamPermissionsResponse { + fn default() -> &'a TestIamPermissionsResponse { + ::default_instance() + } +} + +impl TestIamPermissionsResponse { + pub fn new() -> TestIamPermissionsResponse { + ::std::default::Default::default() + } + + // repeated string permissions = 1; + + + pub fn get_permissions(&self) -> &[::std::string::String] { + &self.permissions + } + pub fn clear_permissions(&mut self) { + self.permissions.clear(); + } + + // Param is passed by value, moved + pub fn set_permissions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.permissions = v; + } + + // Mutable pointer to the field. + pub fn mut_permissions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.permissions + } + + // Take field + pub fn take_permissions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.permissions, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for TestIamPermissionsResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.permissions)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.permissions { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.permissions { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TestIamPermissionsResponse { + TestIamPermissionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "permissions", + |m: &TestIamPermissionsResponse| { &m.permissions }, + |m: &mut TestIamPermissionsResponse| { &mut m.permissions }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TestIamPermissionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TestIamPermissionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TestIamPermissionsResponse, + }; + unsafe { + instance.get(TestIamPermissionsResponse::new) + } + } +} + +impl ::protobuf::Clear for TestIamPermissionsResponse { + fn clear(&mut self) { + self.permissions.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TestIamPermissionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TestIamPermissionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1egoogle/iam/v1/iam_policy.proto\x12\rgoogle.iam.v1\x1a\x1cgoogle/ap\ + i/annotations.proto\x1a\x1agoogle/iam/v1/policy.proto\"`\n\x13SetIamPoli\ + cyRequest\x12\x1a\n\x08resource\x18\x01\x20\x01(\tR\x08resource\x12-\n\ + \x06policy\x18\x02\x20\x01(\x0b2\x15.google.iam.v1.PolicyR\x06policy\"1\ + \n\x13GetIamPolicyRequest\x12\x1a\n\x08resource\x18\x01\x20\x01(\tR\x08r\ + esource\"Y\n\x19TestIamPermissionsRequest\x12\x1a\n\x08resource\x18\x01\ + \x20\x01(\tR\x08resource\x12\x20\n\x0bpermissions\x18\x02\x20\x03(\tR\ + \x0bpermissions\">\n\x1aTestIamPermissionsResponse\x12\x20\n\x0bpermissi\ + ons\x18\x01\x20\x03(\tR\x0bpermissions2\x94\x03\n\tIAMPolicy\x12t\n\x0cS\ + etIamPolicy\x12\".google.iam.v1.SetIamPolicyRequest\x1a\x15.google.iam.v\ + 1.Policy\")\x82\xd3\xe4\x93\x02#\"\x1e/v1/{resource=**}:setIamPolicy:\ + \x01*\x12t\n\x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRequest\x1a\ + \x15.google.iam.v1.Policy\")\x82\xd3\xe4\x93\x02#\"\x1e/v1/{resource=**}\ + :getIamPolicy:\x01*\x12\x9a\x01\n\x12TestIamPermissions\x12(.google.iam.\ + v1.TestIamPermissionsRequest\x1a).google.iam.v1.TestIamPermissionsRespon\ + se\"/\x82\xd3\xe4\x93\x02)\"$/v1/{resource=**}:testIamPermissions:\x01*B\ + \x86\x01\n\x11com.google.iam.v1B\x0eIamPolicyProtoP\x01Z0google.golang.o\ + rg/genproto/googleapis/iam/v1;iam\xf8\x01\x01\xaa\x02\x13Google.Cloud.Ia\ + m.V1\xca\x02\x13Google\\Cloud\\Iam\\V1J\xf1\x20\n\x06\x12\x04\x0e\0v\x01\ + \n\xbd\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202016\x20\ + Google\x20Inc.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20\ + Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\ + \x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20License\ + .\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\ + \n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20\ + Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20i\ + n\x20writing,\x20software\n\x20distributed\x20under\x20the\x20License\ + \x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\ + \x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20ex\ + press\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20spec\ + ific\x20language\x20governing\x20permissions\x20and\n\x20limitations\x20\ + under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x16\n\t\n\x02\ + \x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0$\n\x08\n\x01\x08\ + \x12\x03\x15\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x15\0\x1f\n\x08\n\x01\x08\ + \x12\x03\x16\00\n\t\n\x02\x08%\x12\x03\x16\00\n\x08\n\x01\x08\x12\x03\ + \x17\0G\n\t\n\x02\x08\x0b\x12\x03\x17\0G\n\x08\n\x01\x08\x12\x03\x18\0\"\ + \n\t\n\x02\x08\n\x12\x03\x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0/\n\t\n\ + \x02\x08\x08\x12\x03\x19\0/\n\x08\n\x01\x08\x12\x03\x1a\0*\n\t\n\x02\x08\ + \x01\x12\x03\x1a\0*\n\x08\n\x01\x08\x12\x03\x1b\00\n\t\n\x02\x08)\x12\ + \x03\x1b\00\n\xbb\x07\n\x02\x06\0\x12\x047\0K\x01\x1a\xae\x07\x20##\x20A\ + PI\x20Overview\n\n\x20Manages\x20Identity\x20and\x20Access\x20Management\ + \x20(IAM)\x20policies.\n\n\x20Any\x20implementation\x20of\x20an\x20API\ + \x20that\x20offers\x20access\x20control\x20features\n\x20implements\x20t\ + he\x20google.iam.v1.IAMPolicy\x20interface.\n\n\x20##\x20Data\x20model\n\ + \n\x20Access\x20control\x20is\x20applied\x20when\x20a\x20principal\x20(u\ + ser\x20or\x20service\x20account),\x20takes\n\x20some\x20action\x20on\x20\ + a\x20resource\x20exposed\x20by\x20a\x20service.\x20Resources,\x20identif\ + ied\x20by\n\x20URI-like\x20names,\x20are\x20the\x20unit\x20of\x20access\ + \x20control\x20specification.\x20Service\n\x20implementations\x20can\x20\ + choose\x20the\x20granularity\x20of\x20access\x20control\x20and\x20the\n\ + \x20supported\x20permissions\x20for\x20their\x20resources.\n\x20For\x20e\ + xample\x20one\x20database\x20service\x20may\x20allow\x20access\x20contro\ + l\x20to\x20be\n\x20specified\x20only\x20at\x20the\x20Table\x20level,\x20\ + whereas\x20another\x20might\x20allow\x20access\x20control\n\x20to\x20als\ + o\x20be\x20specified\x20at\x20the\x20Column\x20level.\n\n\x20##\x20Polic\ + y\x20Structure\n\n\x20See\x20google.iam.v1.Policy\n\n\x20This\x20is\x20i\ + ntentionally\x20not\x20a\x20CRUD\x20style\x20API\x20because\x20access\ + \x20control\x20policies\n\x20are\x20created\x20and\x20deleted\x20implici\ + tly\x20with\x20the\x20resources\x20to\x20which\x20they\x20are\n\x20attac\ + hed.\n\n\n\n\x03\x06\0\x01\x12\x037\x08\x11\nh\n\x04\x06\0\x02\0\x12\x04\ + :\x02<\x03\x1aZ\x20Sets\x20the\x20access\x20control\x20policy\x20on\x20t\ + he\x20specified\x20resource.\x20Replaces\x20any\n\x20existing\x20policy.\ + \n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03:\x06\x12\n\x0c\n\x05\x06\0\x02\0\ + \x02\x12\x03:\x13&\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03:17\n\x0c\n\x05\ + \x06\0\x02\0\x04\x12\x03;\x04T\n\x10\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\ + \x12\x03;\x04T\n\x90\x01\n\x04\x06\0\x02\x01\x12\x04A\x02C\x03\x1a\x81\ + \x01\x20Gets\x20the\x20access\x20control\x20policy\x20for\x20a\x20resour\ + ce.\n\x20Returns\x20an\x20empty\x20policy\x20if\x20the\x20resource\x20ex\ + ists\x20and\x20does\x20not\x20have\x20a\x20policy\n\x20set.\n\n\x0c\n\ + \x05\x06\0\x02\x01\x01\x12\x03A\x06\x12\n\x0c\n\x05\x06\0\x02\x01\x02\ + \x12\x03A\x13&\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03A17\n\x0c\n\x05\x06\ + \0\x02\x01\x04\x12\x03B\x04T\n\x10\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\ + \x12\x03B\x04T\n\xb8\x01\n\x04\x06\0\x02\x02\x12\x04H\x02J\x03\x1a\xa9\ + \x01\x20Returns\x20permissions\x20that\x20a\x20caller\x20has\x20on\x20th\ + e\x20specified\x20resource.\n\x20If\x20the\x20resource\x20does\x20not\ + \x20exist,\x20this\x20will\x20return\x20an\x20empty\x20set\x20of\n\x20pe\ + rmissions,\x20not\x20a\x20NOT_FOUND\x20error.\n\n\x0c\n\x05\x06\0\x02\ + \x02\x01\x12\x03H\x06\x18\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03H\x192\n\ + \x0c\n\x05\x06\0\x02\x02\x03\x12\x03H=W\n\x0c\n\x05\x06\0\x02\x02\x04\ + \x12\x03I\x04Z\n\x10\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x03I\x04Z\n\ + 8\n\x02\x04\0\x12\x04N\0Y\x01\x1a,\x20Request\x20message\x20for\x20`SetI\ + amPolicy`\x20method.\n\n\n\n\x03\x04\0\x01\x12\x03N\x08\x1b\n\xc2\x01\n\ + \x04\x04\0\x02\0\x12\x03R\x02\x16\x1a\xb4\x01\x20REQUIRED:\x20The\x20res\ + ource\x20for\x20which\x20the\x20policy\x20is\x20being\x20specified.\n\ + \x20`resource`\x20is\x20usually\x20specified\x20as\x20a\x20path.\x20For\ + \x20example,\x20a\x20Project\n\x20resource\x20is\x20specified\x20as\x20`\ + projects/{project}`.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04R\x02N\x1d\n\x0c\ + \n\x05\x04\0\x02\0\x05\x12\x03R\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\ + \x03R\t\x11\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03R\x14\x15\n\xf3\x01\n\x04\ + \x04\0\x02\x01\x12\x03X\x02\x14\x1a\xe5\x01\x20REQUIRED:\x20The\x20compl\ + ete\x20policy\x20to\x20be\x20applied\x20to\x20the\x20`resource`.\x20The\ + \x20size\x20of\n\x20the\x20policy\x20is\x20limited\x20to\x20a\x20few\x20\ + 10s\x20of\x20KB.\x20An\x20empty\x20policy\x20is\x20a\n\x20valid\x20polic\ + y\x20but\x20certain\x20Cloud\x20Platform\x20services\x20(such\x20as\x20P\ + rojects)\n\x20might\x20reject\x20them.\n\n\r\n\x05\x04\0\x02\x01\x04\x12\ + \x04X\x02R\x16\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03X\x02\x08\n\x0c\n\ + \x05\x04\0\x02\x01\x01\x12\x03X\t\x0f\n\x0c\n\x05\x04\0\x02\x01\x03\x12\ + \x03X\x12\x13\n8\n\x02\x04\x01\x12\x04\\\0a\x01\x1a,\x20Request\x20messa\ + ge\x20for\x20`GetIamPolicy`\x20method.\n\n\n\n\x03\x04\x01\x01\x12\x03\\\ + \x08\x1b\n\xc2\x01\n\x04\x04\x01\x02\0\x12\x03`\x02\x16\x1a\xb4\x01\x20R\ + EQUIRED:\x20The\x20resource\x20for\x20which\x20the\x20policy\x20is\x20be\ + ing\x20requested.\n\x20`resource`\x20is\x20usually\x20specified\x20as\ + \x20a\x20path.\x20For\x20example,\x20a\x20Project\n\x20resource\x20is\ + \x20specified\x20as\x20`projects/{project}`.\n\n\r\n\x05\x04\x01\x02\0\ + \x04\x12\x04`\x02\\\x1d\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03`\x02\x08\n\ + \x0c\n\x05\x04\x01\x02\0\x01\x12\x03`\t\x11\n\x0c\n\x05\x04\x01\x02\0\ + \x03\x12\x03`\x14\x15\n>\n\x02\x04\x02\x12\x04d\0o\x01\x1a2\x20Request\ + \x20message\x20for\x20`TestIamPermissions`\x20method.\n\n\n\n\x03\x04\ + \x02\x01\x12\x03d\x08!\n\xc9\x01\n\x04\x04\x02\x02\0\x12\x03h\x02\x16\ + \x1a\xbb\x01\x20REQUIRED:\x20The\x20resource\x20for\x20which\x20the\x20p\ + olicy\x20detail\x20is\x20being\x20requested.\n\x20`resource`\x20is\x20us\ + ually\x20specified\x20as\x20a\x20path.\x20For\x20example,\x20a\x20Projec\ + t\n\x20resource\x20is\x20specified\x20as\x20`projects/{project}`.\n\n\r\ + \n\x05\x04\x02\x02\0\x04\x12\x04h\x02d#\n\x0c\n\x05\x04\x02\x02\0\x05\ + \x12\x03h\x02\x08\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03h\t\x11\n\x0c\n\ + \x05\x04\x02\x02\0\x03\x12\x03h\x14\x15\n\xf0\x01\n\x04\x04\x02\x02\x01\ + \x12\x03n\x02\"\x1a\xe2\x01\x20The\x20set\x20of\x20permissions\x20to\x20\ + check\x20for\x20the\x20`resource`.\x20Permissions\x20with\n\x20wildcards\ + \x20(such\x20as\x20'*'\x20or\x20'storage.*')\x20are\x20not\x20allowed.\ + \x20For\x20more\n\x20information\x20see\n\x20[IAM\x20Overview](https://c\ + loud.google.com/iam/docs/overview#permissions).\n\n\x0c\n\x05\x04\x02\ + \x02\x01\x04\x12\x03n\x02\n\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03n\x0b\ + \x11\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03n\x12\x1d\n\x0c\n\x05\x04\ + \x02\x02\x01\x03\x12\x03n\x20!\n?\n\x02\x04\x03\x12\x04r\0v\x01\x1a3\x20\ + Response\x20message\x20for\x20`TestIamPermissions`\x20method.\n\n\n\n\ + \x03\x04\x03\x01\x12\x03r\x08\"\n\\\n\x04\x04\x03\x02\0\x12\x03u\x02\"\ + \x1aO\x20A\x20subset\x20of\x20`TestPermissionsRequest.permissions`\x20th\ + at\x20the\x20caller\x20is\n\x20allowed.\n\n\x0c\n\x05\x04\x03\x02\0\x04\ + \x12\x03u\x02\n\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03u\x0b\x11\n\x0c\n\ + \x05\x04\x03\x02\0\x01\x12\x03u\x12\x1d\n\x0c\n\x05\x04\x03\x02\0\x03\ + \x12\x03u\x20!b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy_grpc.rs new file mode 100644 index 00000000..7eb91e87 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/iam_policy_grpc.rs @@ -0,0 +1,127 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_IAM_POLICY_SET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.iam.v1.IAMPolicy/SetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_IAM_POLICY_GET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.iam.v1.IAMPolicy/GetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_IAM_POLICY_TEST_IAM_PERMISSIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.iam.v1.IAMPolicy/TestIamPermissions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct IamPolicyClient { + client: ::grpcio::Client, +} + +impl IamPolicyClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + IamPolicyClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn set_iam_policy_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_IAM_POLICY_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result { + self.set_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_async_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_IAM_POLICY_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy_async(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.set_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_IAM_POLICY_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result { + self.get_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_async_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_IAM_POLICY_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy_async(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_IAM_POLICY_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result { + self.test_iam_permissions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_async_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_IAM_POLICY_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions_async(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.test_iam_permissions_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait IamPolicy { + fn set_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::SetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn get_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::GetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn test_iam_permissions(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::TestIamPermissionsRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_iam_policy(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_IAM_POLICY_SET_IAM_POLICY, move |ctx, req, resp| { + instance.set_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_IAM_POLICY_GET_IAM_POLICY, move |ctx, req, resp| { + instance.get_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_IAM_POLICY_TEST_IAM_PERMISSIONS, move |ctx, req, resp| { + instance.test_iam_permissions(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/mod.rs new file mode 100644 index 00000000..5b512fb2 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/mod.rs @@ -0,0 +1,3 @@ +pub mod iam_policy; +pub mod iam_policy_grpc; +pub mod policy; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/policy.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/policy.rs new file mode 100644 index 00000000..fb34857c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/iam/v1/policy.rs @@ -0,0 +1,1143 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/iam/v1/policy.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Policy { + // message fields + pub version: i32, + pub bindings: ::protobuf::RepeatedField, + pub etag: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Policy { + fn default() -> &'a Policy { + ::default_instance() + } +} + +impl Policy { + pub fn new() -> Policy { + ::std::default::Default::default() + } + + // int32 version = 1; + + + pub fn get_version(&self) -> i32 { + self.version + } + pub fn clear_version(&mut self) { + self.version = 0; + } + + // Param is passed by value, moved + pub fn set_version(&mut self, v: i32) { + self.version = v; + } + + // repeated .google.iam.v1.Binding bindings = 4; + + + pub fn get_bindings(&self) -> &[Binding] { + &self.bindings + } + pub fn clear_bindings(&mut self) { + self.bindings.clear(); + } + + // Param is passed by value, moved + pub fn set_bindings(&mut self, v: ::protobuf::RepeatedField) { + self.bindings = v; + } + + // Mutable pointer to the field. + pub fn mut_bindings(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.bindings + } + + // Take field + pub fn take_bindings(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.bindings, ::protobuf::RepeatedField::new()) + } + + // bytes etag = 3; + + + pub fn get_etag(&self) -> &[u8] { + &self.etag + } + pub fn clear_etag(&mut self) { + self.etag.clear(); + } + + // Param is passed by value, moved + pub fn set_etag(&mut self, v: ::std::vec::Vec) { + self.etag = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_etag(&mut self) -> &mut ::std::vec::Vec { + &mut self.etag + } + + // Take field + pub fn take_etag(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.etag, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for Policy { + fn is_initialized(&self) -> bool { + for v in &self.bindings { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.version = tmp; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.bindings)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.etag)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.version != 0 { + my_size += ::protobuf::rt::value_size(1, self.version, ::protobuf::wire_format::WireTypeVarint); + } + for value in &self.bindings { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.etag.is_empty() { + my_size += ::protobuf::rt::bytes_size(3, &self.etag); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.version != 0 { + os.write_int32(1, self.version)?; + } + for v in &self.bindings { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.etag.is_empty() { + os.write_bytes(3, &self.etag)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Policy { + Policy::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "version", + |m: &Policy| { &m.version }, + |m: &mut Policy| { &mut m.version }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "bindings", + |m: &Policy| { &m.bindings }, + |m: &mut Policy| { &mut m.bindings }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "etag", + |m: &Policy| { &m.etag }, + |m: &mut Policy| { &mut m.etag }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Policy", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Policy { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Policy, + }; + unsafe { + instance.get(Policy::new) + } + } +} + +impl ::protobuf::Clear for Policy { + fn clear(&mut self) { + self.version = 0; + self.bindings.clear(); + self.etag.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Policy { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Policy { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Binding { + // message fields + pub role: ::std::string::String, + pub members: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Binding { + fn default() -> &'a Binding { + ::default_instance() + } +} + +impl Binding { + pub fn new() -> Binding { + ::std::default::Default::default() + } + + // string role = 1; + + + pub fn get_role(&self) -> &str { + &self.role + } + pub fn clear_role(&mut self) { + self.role.clear(); + } + + // Param is passed by value, moved + pub fn set_role(&mut self, v: ::std::string::String) { + self.role = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_role(&mut self) -> &mut ::std::string::String { + &mut self.role + } + + // Take field + pub fn take_role(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.role, ::std::string::String::new()) + } + + // repeated string members = 2; + + + pub fn get_members(&self) -> &[::std::string::String] { + &self.members + } + pub fn clear_members(&mut self) { + self.members.clear(); + } + + // Param is passed by value, moved + pub fn set_members(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.members = v; + } + + // Mutable pointer to the field. + pub fn mut_members(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.members + } + + // Take field + pub fn take_members(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.members, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Binding { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.role)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.members)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.role.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.role); + } + for value in &self.members { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.role.is_empty() { + os.write_string(1, &self.role)?; + } + for v in &self.members { + os.write_string(2, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Binding { + Binding::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "role", + |m: &Binding| { &m.role }, + |m: &mut Binding| { &mut m.role }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "members", + |m: &Binding| { &m.members }, + |m: &mut Binding| { &mut m.members }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Binding", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Binding { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Binding, + }; + unsafe { + instance.get(Binding::new) + } + } +} + +impl ::protobuf::Clear for Binding { + fn clear(&mut self) { + self.role.clear(); + self.members.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Binding { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Binding { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PolicyDelta { + // message fields + pub binding_deltas: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PolicyDelta { + fn default() -> &'a PolicyDelta { + ::default_instance() + } +} + +impl PolicyDelta { + pub fn new() -> PolicyDelta { + ::std::default::Default::default() + } + + // repeated .google.iam.v1.BindingDelta binding_deltas = 1; + + + pub fn get_binding_deltas(&self) -> &[BindingDelta] { + &self.binding_deltas + } + pub fn clear_binding_deltas(&mut self) { + self.binding_deltas.clear(); + } + + // Param is passed by value, moved + pub fn set_binding_deltas(&mut self, v: ::protobuf::RepeatedField) { + self.binding_deltas = v; + } + + // Mutable pointer to the field. + pub fn mut_binding_deltas(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.binding_deltas + } + + // Take field + pub fn take_binding_deltas(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.binding_deltas, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PolicyDelta { + fn is_initialized(&self) -> bool { + for v in &self.binding_deltas { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.binding_deltas)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.binding_deltas { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.binding_deltas { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PolicyDelta { + PolicyDelta::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "binding_deltas", + |m: &PolicyDelta| { &m.binding_deltas }, + |m: &mut PolicyDelta| { &mut m.binding_deltas }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PolicyDelta", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PolicyDelta { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PolicyDelta, + }; + unsafe { + instance.get(PolicyDelta::new) + } + } +} + +impl ::protobuf::Clear for PolicyDelta { + fn clear(&mut self) { + self.binding_deltas.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PolicyDelta { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PolicyDelta { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct BindingDelta { + // message fields + pub action: BindingDelta_Action, + pub role: ::std::string::String, + pub member: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BindingDelta { + fn default() -> &'a BindingDelta { + ::default_instance() + } +} + +impl BindingDelta { + pub fn new() -> BindingDelta { + ::std::default::Default::default() + } + + // .google.iam.v1.BindingDelta.Action action = 1; + + + pub fn get_action(&self) -> BindingDelta_Action { + self.action + } + pub fn clear_action(&mut self) { + self.action = BindingDelta_Action::ACTION_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_action(&mut self, v: BindingDelta_Action) { + self.action = v; + } + + // string role = 2; + + + pub fn get_role(&self) -> &str { + &self.role + } + pub fn clear_role(&mut self) { + self.role.clear(); + } + + // Param is passed by value, moved + pub fn set_role(&mut self, v: ::std::string::String) { + self.role = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_role(&mut self) -> &mut ::std::string::String { + &mut self.role + } + + // Take field + pub fn take_role(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.role, ::std::string::String::new()) + } + + // string member = 3; + + + pub fn get_member(&self) -> &str { + &self.member + } + pub fn clear_member(&mut self) { + self.member.clear(); + } + + // Param is passed by value, moved + pub fn set_member(&mut self, v: ::std::string::String) { + self.member = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_member(&mut self) -> &mut ::std::string::String { + &mut self.member + } + + // Take field + pub fn take_member(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.member, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for BindingDelta { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.action, 1, &mut self.unknown_fields)? + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.role)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.member)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.action != BindingDelta_Action::ACTION_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(1, self.action); + } + if !self.role.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.role); + } + if !self.member.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.member); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.action != BindingDelta_Action::ACTION_UNSPECIFIED { + os.write_enum(1, self.action.value())?; + } + if !self.role.is_empty() { + os.write_string(2, &self.role)?; + } + if !self.member.is_empty() { + os.write_string(3, &self.member)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BindingDelta { + BindingDelta::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "action", + |m: &BindingDelta| { &m.action }, + |m: &mut BindingDelta| { &mut m.action }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "role", + |m: &BindingDelta| { &m.role }, + |m: &mut BindingDelta| { &mut m.role }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "member", + |m: &BindingDelta| { &m.member }, + |m: &mut BindingDelta| { &mut m.member }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BindingDelta", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BindingDelta { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BindingDelta, + }; + unsafe { + instance.get(BindingDelta::new) + } + } +} + +impl ::protobuf::Clear for BindingDelta { + fn clear(&mut self) { + self.action = BindingDelta_Action::ACTION_UNSPECIFIED; + self.role.clear(); + self.member.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BindingDelta { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BindingDelta { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum BindingDelta_Action { + ACTION_UNSPECIFIED = 0, + ADD = 1, + REMOVE = 2, +} + +impl ::protobuf::ProtobufEnum for BindingDelta_Action { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(BindingDelta_Action::ACTION_UNSPECIFIED), + 1 => ::std::option::Option::Some(BindingDelta_Action::ADD), + 2 => ::std::option::Option::Some(BindingDelta_Action::REMOVE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [BindingDelta_Action] = &[ + BindingDelta_Action::ACTION_UNSPECIFIED, + BindingDelta_Action::ADD, + BindingDelta_Action::REMOVE, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("BindingDelta_Action", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for BindingDelta_Action { +} + +impl ::std::default::Default for BindingDelta_Action { + fn default() -> Self { + BindingDelta_Action::ACTION_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for BindingDelta_Action { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1agoogle/iam/v1/policy.proto\x12\rgoogle.iam.v1\x1a\x1cgoogle/api/an\ + notations.proto\"j\n\x06Policy\x12\x18\n\x07version\x18\x01\x20\x01(\x05\ + R\x07version\x122\n\x08bindings\x18\x04\x20\x03(\x0b2\x16.google.iam.v1.\ + BindingR\x08bindings\x12\x12\n\x04etag\x18\x03\x20\x01(\x0cR\x04etag\"7\ + \n\x07Binding\x12\x12\n\x04role\x18\x01\x20\x01(\tR\x04role\x12\x18\n\ + \x07members\x18\x02\x20\x03(\tR\x07members\"Q\n\x0bPolicyDelta\x12B\n\ + \x0ebinding_deltas\x18\x01\x20\x03(\x0b2\x1b.google.iam.v1.BindingDeltaR\ + \rbindingDeltas\"\xad\x01\n\x0cBindingDelta\x12:\n\x06action\x18\x01\x20\ + \x01(\x0e2\".google.iam.v1.BindingDelta.ActionR\x06action\x12\x12\n\x04r\ + ole\x18\x02\x20\x01(\tR\x04role\x12\x16\n\x06member\x18\x03\x20\x01(\tR\ + \x06member\"5\n\x06Action\x12\x16\n\x12ACTION_UNSPECIFIED\x10\0\x12\x07\ + \n\x03ADD\x10\x01\x12\n\n\x06REMOVE\x10\x02B\x83\x01\n\x11com.google.iam\ + .v1B\x0bPolicyProtoP\x01Z0google.golang.org/genproto/googleapis/iam/v1;i\ + am\xf8\x01\x01\xaa\x02\x13Google.Cloud.Iam.V1\xca\x02\x13Google\\Cloud\\\ + Iam\\V1J\xb5(\n\x07\x12\x05\x0e\0\x95\x01\x01\n\xbd\x04\n\x01\x0c\x12\ + \x03\x0e\0\x122\xb2\x04\x20Copyright\x202016\x20Google\x20Inc.\n\n\x20Li\ + censed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\ + \x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20excep\ + t\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obta\ + in\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20htt\ + p://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\ + \x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20softwar\ + e\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\ + \x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CON\ + DITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\ + \x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20gover\ + ning\x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\ + \n\n\x08\n\x01\x02\x12\x03\x10\0\x16\n\t\n\x02\x03\0\x12\x03\x12\0&\n\ + \x08\n\x01\x08\x12\x03\x14\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x14\0\x1f\n\ + \x08\n\x01\x08\x12\x03\x15\00\n\t\n\x02\x08%\x12\x03\x15\00\n\x08\n\x01\ + \x08\x12\x03\x16\0G\n\t\n\x02\x08\x0b\x12\x03\x16\0G\n\x08\n\x01\x08\x12\ + \x03\x17\0\"\n\t\n\x02\x08\n\x12\x03\x17\0\"\n\x08\n\x01\x08\x12\x03\x18\ + \0,\n\t\n\x02\x08\x08\x12\x03\x18\0,\n\x08\n\x01\x08\x12\x03\x19\0*\n\t\ + \n\x02\x08\x01\x12\x03\x19\0*\n\x08\n\x01\x08\x12\x03\x1a\00\n\t\n\x02\ + \x08)\x12\x03\x1a\00\n\xb6\x07\n\x02\x04\0\x12\x04<\0P\x01\x1a\xa9\x07\ + \x20Defines\x20an\x20Identity\x20and\x20Access\x20Management\x20(IAM)\ + \x20policy.\x20It\x20is\x20used\x20to\n\x20specify\x20access\x20control\ + \x20policies\x20for\x20Cloud\x20Platform\x20resources.\n\n\n\x20A\x20`Po\ + licy`\x20consists\x20of\x20a\x20list\x20of\x20`bindings`.\x20A\x20`Bindi\ + ng`\x20binds\x20a\x20list\x20of\n\x20`members`\x20to\x20a\x20`role`,\x20\ + where\x20the\x20members\x20can\x20be\x20user\x20accounts,\x20Google\x20g\ + roups,\n\x20Google\x20domains,\x20and\x20service\x20accounts.\x20A\x20`r\ + ole`\x20is\x20a\x20named\x20list\x20of\x20permissions\n\x20defined\x20by\ + \x20IAM.\n\n\x20**Example**\n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\ + \x20\x20\x20\"bindings\":\x20[\n\x20\x20\x20\x20\x20\x20\x20\x20\x20{\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"role\":\x20\"roles/owner\"\ + ,\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"members\":\x20[\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"user:mike@example.com\ + \",\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"group:admins@\ + example.com\",\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\"do\ + main:google.com\",\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \"serviceAccount:my-other-app@appspot.gserviceaccount.com\",\n\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20]\n\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20},\n\x20\x20\x20\x20\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\"role\":\x20\"roles/viewer\",\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\"members\":\x20[\"user:sean@example.com\"]\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20]\n\ + \x20\x20\x20\x20\x20}\n\n\x20For\x20a\x20description\x20of\x20IAM\x20and\ + \x20its\x20features,\x20see\x20the\n\x20[IAM\x20developer's\x20guide](ht\ + tps://cloud.google.com/iam).\n\n\n\n\x03\x04\0\x01\x12\x03<\x08\x0e\nA\n\ + \x04\x04\0\x02\0\x12\x03>\x02\x14\x1a4\x20Version\x20of\x20the\x20`Polic\ + y`.\x20The\x20default\x20version\x20is\x200.\n\n\r\n\x05\x04\0\x02\0\x04\ + \x12\x04>\x02<\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03>\x02\x07\n\x0c\n\ + \x05\x04\0\x02\0\x01\x12\x03>\x08\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\ + \x03>\x12\x13\n\xb0\x01\n\x04\x04\0\x02\x01\x12\x03C\x02\x20\x1a\xa2\x01\ + \x20Associates\x20a\x20list\x20of\x20`members`\x20to\x20a\x20`role`.\n\ + \x20Multiple\x20`bindings`\x20must\x20not\x20be\x20specified\x20for\x20t\ + he\x20same\x20`role`.\n\x20`bindings`\x20with\x20no\x20members\x20will\ + \x20result\x20in\x20an\x20error.\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\ + C\x02\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03C\x0b\x12\n\x0c\n\x05\x04\0\ + \x02\x01\x01\x12\x03C\x13\x1b\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03C\x1e\ + \x1f\n\xf6\x04\n\x04\x04\0\x02\x02\x12\x03O\x02\x11\x1a\xe8\x04\x20`etag\ + `\x20is\x20used\x20for\x20optimistic\x20concurrency\x20control\x20as\x20\ + a\x20way\x20to\x20help\n\x20prevent\x20simultaneous\x20updates\x20of\x20\ + a\x20policy\x20from\x20overwriting\x20each\x20other.\n\x20It\x20is\x20st\ + rongly\x20suggested\x20that\x20systems\x20make\x20use\x20of\x20the\x20`e\ + tag`\x20in\x20the\n\x20read-modify-write\x20cycle\x20to\x20perform\x20po\ + licy\x20updates\x20in\x20order\x20to\x20avoid\x20race\n\x20conditions:\ + \x20An\x20`etag`\x20is\x20returned\x20in\x20the\x20response\x20to\x20`ge\ + tIamPolicy`,\x20and\n\x20systems\x20are\x20expected\x20to\x20put\x20that\ + \x20etag\x20in\x20the\x20request\x20to\x20`setIamPolicy`\x20to\n\x20ensu\ + re\x20that\x20their\x20change\x20will\x20be\x20applied\x20to\x20the\x20s\ + ame\x20version\x20of\x20the\x20policy.\n\n\x20If\x20no\x20`etag`\x20is\ + \x20provided\x20in\x20the\x20call\x20to\x20`setIamPolicy`,\x20then\x20th\ + e\x20existing\n\x20policy\x20is\x20overwritten\x20blindly.\n\n\r\n\x05\ + \x04\0\x02\x02\x04\x12\x04O\x02C\x20\n\x0c\n\x05\x04\0\x02\x02\x05\x12\ + \x03O\x02\x07\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03O\x08\x0c\n\x0c\n\x05\ + \x04\0\x02\x02\x03\x12\x03O\x0f\x10\n1\n\x02\x04\x01\x12\x04S\0q\x01\x1a\ + %\x20Associates\x20`members`\x20with\x20a\x20`role`.\n\n\n\n\x03\x04\x01\ + \x01\x12\x03S\x08\x0f\n|\n\x04\x04\x01\x02\0\x12\x03W\x02\x12\x1ao\x20Ro\ + le\x20that\x20is\x20assigned\x20to\x20`members`.\n\x20For\x20example,\ + \x20`roles/viewer`,\x20`roles/editor`,\x20or\x20`roles/owner`.\n\x20Requ\ + ired\n\n\r\n\x05\x04\x01\x02\0\x04\x12\x04W\x02S\x11\n\x0c\n\x05\x04\x01\ + \x02\0\x05\x12\x03W\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03W\t\r\n\ + \x0c\n\x05\x04\x01\x02\0\x03\x12\x03W\x10\x11\n\xa8\x07\n\x04\x04\x01\ + \x02\x01\x12\x03p\x02\x1e\x1a\x9a\x07\x20Specifies\x20the\x20identities\ + \x20requesting\x20access\x20for\x20a\x20Cloud\x20Platform\x20resource.\n\ + \x20`members`\x20can\x20have\x20the\x20following\x20values:\n\n\x20*\x20\ + `allUsers`:\x20A\x20special\x20identifier\x20that\x20represents\x20anyon\ + e\x20who\x20is\n\x20\x20\x20\x20on\x20the\x20internet;\x20with\x20or\x20\ + without\x20a\x20Google\x20account.\n\n\x20*\x20`allAuthenticatedUsers`:\ + \x20A\x20special\x20identifier\x20that\x20represents\x20anyone\n\x20\x20\ + \x20\x20who\x20is\x20authenticated\x20with\x20a\x20Google\x20account\x20\ + or\x20a\x20service\x20account.\n\n\x20*\x20`user:{emailid}`:\x20An\x20em\ + ail\x20address\x20that\x20represents\x20a\x20specific\x20Google\n\x20\ + \x20\x20\x20account.\x20For\x20example,\x20`alice@gmail.com`\x20or\x20`j\ + oe@example.com`.\n\n\n\x20*\x20`serviceAccount:{emailid}`:\x20An\x20emai\ + l\x20address\x20that\x20represents\x20a\x20service\n\x20\x20\x20\x20acco\ + unt.\x20For\x20example,\x20`my-other-app@appspot.gserviceaccount.com`.\n\ + \n\x20*\x20`group:{emailid}`:\x20An\x20email\x20address\x20that\x20repre\ + sents\x20a\x20Google\x20group.\n\x20\x20\x20\x20For\x20example,\x20`admi\ + ns@example.com`.\n\n\x20*\x20`domain:{domain}`:\x20A\x20Google\x20Apps\ + \x20domain\x20name\x20that\x20represents\x20all\x20the\n\x20\x20\x20\x20\ + users\x20of\x20that\x20domain.\x20For\x20example,\x20`google.com`\x20or\ + \x20`example.com`.\n\n\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03p\x02\n\ + \n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03p\x0b\x11\n\x0c\n\x05\x04\x01\ + \x02\x01\x01\x12\x03p\x12\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03p\ + \x1c\x1d\n8\n\x02\x04\x02\x12\x04t\0w\x01\x1a,\x20The\x20difference\x20d\ + elta\x20between\x20two\x20policies.\n\n\n\n\x03\x04\x02\x01\x12\x03t\x08\ + \x13\n;\n\x04\x04\x02\x02\0\x12\x03v\x02+\x1a.\x20The\x20delta\x20for\ + \x20Bindings\x20between\x20two\x20policies.\n\n\x0c\n\x05\x04\x02\x02\0\ + \x04\x12\x03v\x02\n\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x03v\x0b\x17\n\x0c\ + \n\x05\x04\x02\x02\0\x01\x12\x03v\x18&\n\x0c\n\x05\x04\x02\x02\0\x03\x12\ + \x03v)*\n\x8a\x01\n\x02\x04\x03\x12\x05{\0\x95\x01\x01\x1a}\x20One\x20de\ + lta\x20entry\x20for\x20Binding.\x20Each\x20individual\x20change\x20(only\ + \x20one\x20member\x20in\x20each\n\x20entry)\x20to\x20a\x20binding\x20wil\ + l\x20be\x20a\x20separate\x20entry.\n\n\n\n\x03\x04\x03\x01\x12\x03{\x08\ + \x14\nG\n\x04\x04\x03\x04\0\x12\x05}\x02\x86\x01\x03\x1a8\x20The\x20type\ + \x20of\x20action\x20performed\x20on\x20a\x20Binding\x20in\x20a\x20policy\ + .\n\n\x0c\n\x05\x04\x03\x04\0\x01\x12\x03}\x07\r\n\x1d\n\x06\x04\x03\x04\ + \0\x02\0\x12\x03\x7f\x04\x1b\x1a\x0e\x20Unspecified.\n\n\x0e\n\x07\x04\ + \x03\x04\0\x02\0\x01\x12\x03\x7f\x04\x16\n\x0e\n\x07\x04\x03\x04\0\x02\0\ + \x02\x12\x03\x7f\x19\x1a\n(\n\x06\x04\x03\x04\0\x02\x01\x12\x04\x82\x01\ + \x04\x0c\x1a\x18\x20Addition\x20of\x20a\x20Binding.\n\n\x0f\n\x07\x04\ + \x03\x04\0\x02\x01\x01\x12\x04\x82\x01\x04\x07\n\x0f\n\x07\x04\x03\x04\0\ + \x02\x01\x02\x12\x04\x82\x01\n\x0b\n'\n\x06\x04\x03\x04\0\x02\x02\x12\ + \x04\x85\x01\x04\x0f\x1a\x17\x20Removal\x20of\x20a\x20Binding.\n\n\x0f\n\ + \x07\x04\x03\x04\0\x02\x02\x01\x12\x04\x85\x01\x04\n\n\x0f\n\x07\x04\x03\ + \x04\0\x02\x02\x02\x12\x04\x85\x01\r\x0e\nE\n\x04\x04\x03\x02\0\x12\x04\ + \x8a\x01\x02\x14\x1a7\x20The\x20action\x20that\x20was\x20performed\x20on\ + \x20a\x20Binding.\n\x20Required\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\ + \x8a\x01\x02\x86\x01\x03\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\x8a\x01\x02\ + \x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x8a\x01\t\x0f\n\r\n\x05\x04\x03\ + \x02\0\x03\x12\x04\x8a\x01\x12\x13\n}\n\x04\x04\x03\x02\x01\x12\x04\x8f\ + \x01\x02\x12\x1ao\x20Role\x20that\x20is\x20assigned\x20to\x20`members`.\ + \n\x20For\x20example,\x20`roles/viewer`,\x20`roles/editor`,\x20or\x20`ro\ + les/owner`.\n\x20Required\n\n\x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\x8f\ + \x01\x02\x8a\x01\x14\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\x8f\x01\x02\ + \x08\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x8f\x01\t\r\n\r\n\x05\x04\x03\ + \x02\x01\x03\x12\x04\x8f\x01\x10\x11\n\x89\x01\n\x04\x04\x03\x02\x02\x12\ + \x04\x94\x01\x02\x14\x1a{\x20A\x20single\x20identity\x20requesting\x20ac\ + cess\x20for\x20a\x20Cloud\x20Platform\x20resource.\n\x20Follows\x20the\ + \x20same\x20format\x20of\x20Binding.members.\n\x20Required\n\n\x0f\n\x05\ + \x04\x03\x02\x02\x04\x12\x06\x94\x01\x02\x8f\x01\x12\n\r\n\x05\x04\x03\ + \x02\x02\x05\x12\x04\x94\x01\x02\x08\n\r\n\x05\x04\x03\x02\x02\x01\x12\ + \x04\x94\x01\t\x0f\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\x94\x01\x12\x13\ + b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/lib.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/lib.rs new file mode 100644 index 00000000..b70f4f4c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/lib.rs @@ -0,0 +1,10 @@ +#![allow(bare_trait_objects)] + +pub mod bigtable; +pub mod pubsub; +pub mod spanner; + +pub mod empty; +pub(crate) mod iam; +pub mod longrunning; +pub(crate) mod rpc; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/mod.rs new file mode 100644 index 00000000..c2dcd643 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/mod.rs @@ -0,0 +1,4 @@ +pub mod operations; +pub mod operations_grpc; + +pub(crate) use crate::{empty, rpc::status}; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations.rs new file mode 100644 index 00000000..36aff74e --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations.rs @@ -0,0 +1,1700 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/longrunning/operations.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Operation { + // message fields + pub name: ::std::string::String, + pub metadata: ::protobuf::SingularPtrField<::protobuf::well_known_types::Any>, + pub done: bool, + // message oneof groups + pub result: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Operation { + fn default() -> &'a Operation { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum Operation_oneof_result { + error(super::status::Status), + response(::protobuf::well_known_types::Any), +} + +impl Operation { + pub fn new() -> Operation { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.protobuf.Any metadata = 2; + + + pub fn get_metadata(&self) -> &::protobuf::well_known_types::Any { + self.metadata.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Any::default_instance()) + } + pub fn clear_metadata(&mut self) { + self.metadata.clear(); + } + + pub fn has_metadata(&self) -> bool { + self.metadata.is_some() + } + + // Param is passed by value, moved + pub fn set_metadata(&mut self, v: ::protobuf::well_known_types::Any) { + self.metadata = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_metadata(&mut self) -> &mut ::protobuf::well_known_types::Any { + if self.metadata.is_none() { + self.metadata.set_default(); + } + self.metadata.as_mut().unwrap() + } + + // Take field + pub fn take_metadata(&mut self) -> ::protobuf::well_known_types::Any { + self.metadata.take().unwrap_or_else(|| ::protobuf::well_known_types::Any::new()) + } + + // bool done = 3; + + + pub fn get_done(&self) -> bool { + self.done + } + pub fn clear_done(&mut self) { + self.done = false; + } + + // Param is passed by value, moved + pub fn set_done(&mut self, v: bool) { + self.done = v; + } + + // .google.rpc.Status error = 4; + + + pub fn get_error(&self) -> &super::status::Status { + match self.result { + ::std::option::Option::Some(Operation_oneof_result::error(ref v)) => v, + _ => super::status::Status::default_instance(), + } + } + pub fn clear_error(&mut self) { + self.result = ::std::option::Option::None; + } + + pub fn has_error(&self) -> bool { + match self.result { + ::std::option::Option::Some(Operation_oneof_result::error(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_error(&mut self, v: super::status::Status) { + self.result = ::std::option::Option::Some(Operation_oneof_result::error(v)) + } + + // Mutable pointer to the field. + pub fn mut_error(&mut self) -> &mut super::status::Status { + if let ::std::option::Option::Some(Operation_oneof_result::error(_)) = self.result { + } else { + self.result = ::std::option::Option::Some(Operation_oneof_result::error(super::status::Status::new())); + } + match self.result { + ::std::option::Option::Some(Operation_oneof_result::error(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_error(&mut self) -> super::status::Status { + if self.has_error() { + match self.result.take() { + ::std::option::Option::Some(Operation_oneof_result::error(v)) => v, + _ => panic!(), + } + } else { + super::status::Status::new() + } + } + + // .google.protobuf.Any response = 5; + + + pub fn get_response(&self) -> &::protobuf::well_known_types::Any { + match self.result { + ::std::option::Option::Some(Operation_oneof_result::response(ref v)) => v, + _ => ::protobuf::well_known_types::Any::default_instance(), + } + } + pub fn clear_response(&mut self) { + self.result = ::std::option::Option::None; + } + + pub fn has_response(&self) -> bool { + match self.result { + ::std::option::Option::Some(Operation_oneof_result::response(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_response(&mut self, v: ::protobuf::well_known_types::Any) { + self.result = ::std::option::Option::Some(Operation_oneof_result::response(v)) + } + + // Mutable pointer to the field. + pub fn mut_response(&mut self) -> &mut ::protobuf::well_known_types::Any { + if let ::std::option::Option::Some(Operation_oneof_result::response(_)) = self.result { + } else { + self.result = ::std::option::Option::Some(Operation_oneof_result::response(::protobuf::well_known_types::Any::new())); + } + match self.result { + ::std::option::Option::Some(Operation_oneof_result::response(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_response(&mut self) -> ::protobuf::well_known_types::Any { + if self.has_response() { + match self.result.take() { + ::std::option::Option::Some(Operation_oneof_result::response(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Any::new() + } + } +} + +impl ::protobuf::Message for Operation { + fn is_initialized(&self) -> bool { + for v in &self.metadata { + if !v.is_initialized() { + return false; + } + }; + if let Some(Operation_oneof_result::error(ref v)) = self.result { + if !v.is_initialized() { + return false; + } + } + if let Some(Operation_oneof_result::response(ref v)) = self.result { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.done = tmp; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.result = ::std::option::Option::Some(Operation_oneof_result::error(is.read_message()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.result = ::std::option::Option::Some(Operation_oneof_result::response(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.metadata.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.done != false { + my_size += 2; + } + if let ::std::option::Option::Some(ref v) = self.result { + match v { + &Operation_oneof_result::error(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Operation_oneof_result::response(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.metadata.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.done != false { + os.write_bool(3, self.done)?; + } + if let ::std::option::Option::Some(ref v) = self.result { + match v { + &Operation_oneof_result::error(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Operation_oneof_result::response(ref v) => { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Operation { + Operation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Operation| { &m.name }, + |m: &mut Operation| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>( + "metadata", + |m: &Operation| { &m.metadata }, + |m: &mut Operation| { &mut m.metadata }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "done", + |m: &Operation| { &m.done }, + |m: &mut Operation| { &mut m.done }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::status::Status>( + "error", + Operation::has_error, + Operation::get_error, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Any>( + "response", + Operation::has_response, + Operation::get_response, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Operation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Operation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Operation, + }; + unsafe { + instance.get(Operation::new) + } + } +} + +impl ::protobuf::Clear for Operation { + fn clear(&mut self) { + self.name.clear(); + self.metadata.clear(); + self.done = false; + self.result = ::std::option::Option::None; + self.result = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Operation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Operation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetOperationRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetOperationRequest { + fn default() -> &'a GetOperationRequest { + ::default_instance() + } +} + +impl GetOperationRequest { + pub fn new() -> GetOperationRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetOperationRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetOperationRequest { + GetOperationRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetOperationRequest| { &m.name }, + |m: &mut GetOperationRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetOperationRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetOperationRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetOperationRequest, + }; + unsafe { + instance.get(GetOperationRequest::new) + } + } +} + +impl ::protobuf::Clear for GetOperationRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetOperationRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetOperationRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListOperationsRequest { + // message fields + pub name: ::std::string::String, + pub filter: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListOperationsRequest { + fn default() -> &'a ListOperationsRequest { + ::default_instance() + } +} + +impl ListOperationsRequest { + pub fn new() -> ListOperationsRequest { + ::std::default::Default::default() + } + + // string name = 4; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string filter = 1; + + + pub fn get_filter(&self) -> &str { + &self.filter + } + pub fn clear_filter(&mut self) { + self.filter.clear(); + } + + // Param is passed by value, moved + pub fn set_filter(&mut self, v: ::std::string::String) { + self.filter = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_filter(&mut self) -> &mut ::std::string::String { + &mut self.filter + } + + // Take field + pub fn take_filter(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.filter, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListOperationsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filter)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.name); + } + if !self.filter.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.filter); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(4, &self.name)?; + } + if !self.filter.is_empty() { + os.write_string(1, &self.filter)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListOperationsRequest { + ListOperationsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ListOperationsRequest| { &m.name }, + |m: &mut ListOperationsRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "filter", + |m: &ListOperationsRequest| { &m.filter }, + |m: &mut ListOperationsRequest| { &mut m.filter }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListOperationsRequest| { &m.page_size }, + |m: &mut ListOperationsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListOperationsRequest| { &m.page_token }, + |m: &mut ListOperationsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListOperationsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListOperationsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListOperationsRequest, + }; + unsafe { + instance.get(ListOperationsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListOperationsRequest { + fn clear(&mut self) { + self.name.clear(); + self.filter.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListOperationsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListOperationsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListOperationsResponse { + // message fields + pub operations: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListOperationsResponse { + fn default() -> &'a ListOperationsResponse { + ::default_instance() + } +} + +impl ListOperationsResponse { + pub fn new() -> ListOperationsResponse { + ::std::default::Default::default() + } + + // repeated .google.longrunning.Operation operations = 1; + + + pub fn get_operations(&self) -> &[Operation] { + &self.operations + } + pub fn clear_operations(&mut self) { + self.operations.clear(); + } + + // Param is passed by value, moved + pub fn set_operations(&mut self, v: ::protobuf::RepeatedField) { + self.operations = v; + } + + // Mutable pointer to the field. + pub fn mut_operations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.operations + } + + // Take field + pub fn take_operations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.operations, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListOperationsResponse { + fn is_initialized(&self) -> bool { + for v in &self.operations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.operations)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.operations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.operations { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListOperationsResponse { + ListOperationsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "operations", + |m: &ListOperationsResponse| { &m.operations }, + |m: &mut ListOperationsResponse| { &mut m.operations }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListOperationsResponse| { &m.next_page_token }, + |m: &mut ListOperationsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListOperationsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListOperationsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListOperationsResponse, + }; + unsafe { + instance.get(ListOperationsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListOperationsResponse { + fn clear(&mut self) { + self.operations.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListOperationsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListOperationsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CancelOperationRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CancelOperationRequest { + fn default() -> &'a CancelOperationRequest { + ::default_instance() + } +} + +impl CancelOperationRequest { + pub fn new() -> CancelOperationRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for CancelOperationRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CancelOperationRequest { + CancelOperationRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CancelOperationRequest| { &m.name }, + |m: &mut CancelOperationRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CancelOperationRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CancelOperationRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CancelOperationRequest, + }; + unsafe { + instance.get(CancelOperationRequest::new) + } + } +} + +impl ::protobuf::Clear for CancelOperationRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CancelOperationRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CancelOperationRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteOperationRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteOperationRequest { + fn default() -> &'a DeleteOperationRequest { + ::default_instance() + } +} + +impl DeleteOperationRequest { + pub fn new() -> DeleteOperationRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteOperationRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteOperationRequest { + DeleteOperationRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteOperationRequest| { &m.name }, + |m: &mut DeleteOperationRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteOperationRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteOperationRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteOperationRequest, + }; + unsafe { + instance.get(DeleteOperationRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteOperationRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteOperationRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteOperationRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n#google/longrunning/operations.proto\x12\x12google.longrunning\x1a\x1c\ + google/api/annotations.proto\x1a\x19google/protobuf/any.proto\x1a\x1bgoo\ + gle/protobuf/empty.proto\x1a\x17google/rpc/status.proto\"\xcf\x01\n\tOpe\ + ration\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x120\n\x08metadata\ + \x18\x02\x20\x01(\x0b2\x14.google.protobuf.AnyR\x08metadata\x12\x12\n\ + \x04done\x18\x03\x20\x01(\x08R\x04done\x12*\n\x05error\x18\x04\x20\x01(\ + \x0b2\x12.google.rpc.StatusH\0R\x05error\x122\n\x08response\x18\x05\x20\ + \x01(\x0b2\x14.google.protobuf.AnyH\0R\x08responseB\x08\n\x06result\")\n\ + \x13GetOperationRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\ + \x7f\n\x15ListOperationsRequest\x12\x12\n\x04name\x18\x04\x20\x01(\tR\ + \x04name\x12\x16\n\x06filter\x18\x01\x20\x01(\tR\x06filter\x12\x1b\n\tpa\ + ge_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x03\ + \x20\x01(\tR\tpageToken\"\x7f\n\x16ListOperationsResponse\x12=\n\noperat\ + ions\x18\x01\x20\x03(\x0b2\x1d.google.longrunning.OperationR\noperations\ + \x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\",\n\x16Ca\ + ncelOperationRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\",\n\ + \x16DeleteOperationRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\ + 2\x8c\x04\n\nOperations\x12\x86\x01\n\x0eListOperations\x12).google.long\ + running.ListOperationsRequest\x1a*.google.longrunning.ListOperationsResp\ + onse\"\x1d\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=operations}\x12x\n\ + \x0cGetOperation\x12'.google.longrunning.GetOperationRequest\x1a\x1d.goo\ + gle.longrunning.Operation\"\x20\x82\xd3\xe4\x93\x02\x1a\x12\x18/v1/{name\ + =operations/**}\x12w\n\x0fDeleteOperation\x12*.google.longrunning.Delete\ + OperationRequest\x1a\x16.google.protobuf.Empty\"\x20\x82\xd3\xe4\x93\x02\ + \x1a*\x18/v1/{name=operations/**}\x12\x81\x01\n\x0fCancelOperation\x12*.\ + google.longrunning.CancelOperationRequest\x1a\x16.google.protobuf.Empty\ + \"*\x82\xd3\xe4\x93\x02$\"\x1f/v1/{name=operations/**}:cancel:\x01*B\x94\ + \x01\n\x16com.google.longrunningB\x0fOperationsProtoP\x01Z=google.golang\ + .org/genproto/googleapis/longrunning;longrunning\xaa\x02\x12Google.LongR\ + unning\xca\x02\x12Google\\LongRunningJ\xed4\n\x07\x12\x05\x0e\0\x9e\x01\ + \x01\n\xbd\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202016\ + \x20Google\x20Inc.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\ + \x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20us\ + e\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20Licens\ + e.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\ + \n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\ + \x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\ + \x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\x20Licen\ + se\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHO\ + UT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20\ + express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20sp\ + ecific\x20language\x20governing\x20permissions\x20and\n\x20limitations\ + \x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1b\n\t\n\ + \x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0#\n\t\n\x02\x03\ + \x02\x12\x03\x14\0%\n\t\n\x02\x03\x03\x12\x03\x15\0!\n\x08\n\x01\x08\x12\ + \x03\x17\0/\n\t\n\x02\x08%\x12\x03\x17\0/\n\x08\n\x01\x08\x12\x03\x18\0T\ + \n\t\n\x02\x08\x0b\x12\x03\x18\0T\n\x08\n\x01\x08\x12\x03\x19\0\"\n\t\n\ + \x02\x08\n\x12\x03\x19\0\"\n\x08\n\x01\x08\x12\x03\x1a\00\n\t\n\x02\x08\ + \x08\x12\x03\x1a\00\n\x08\n\x01\x08\x12\x03\x1b\0/\n\t\n\x02\x08\x01\x12\ + \x03\x1b\0/\n\x08\n\x01\x08\x12\x03\x1c\0-\n\t\n\x02\x08)\x12\x03\x1c\0-\ + \n\xd2\x04\n\x02\x06\0\x12\x04(\0N\x01\x1a\xc5\x04\x20Manages\x20long-ru\ + nning\x20operations\x20with\x20an\x20API\x20service.\n\n\x20When\x20an\ + \x20API\x20method\x20normally\x20takes\x20long\x20time\x20to\x20complete\ + ,\x20it\x20can\x20be\x20designed\n\x20to\x20return\x20[Operation][google\ + .longrunning.Operation]\x20to\x20the\x20client,\x20and\x20the\x20client\ + \x20can\x20use\x20this\n\x20interface\x20to\x20receive\x20the\x20real\ + \x20response\x20asynchronously\x20by\x20polling\x20the\n\x20operation\ + \x20resource,\x20or\x20pass\x20the\x20operation\x20resource\x20to\x20ano\ + ther\x20API\x20(such\x20as\n\x20Google\x20Cloud\x20Pub/Sub\x20API)\x20to\ + \x20receive\x20the\x20response.\x20\x20Any\x20API\x20service\x20that\n\ + \x20returns\x20long-running\x20operations\x20should\x20implement\x20the\ + \x20`Operations`\x20interface\n\x20so\x20developers\x20can\x20have\x20a\ + \x20consistent\x20client\x20experience.\n\n\n\n\x03\x06\0\x01\x12\x03(\ + \x08\x12\n\xad\x02\n\x04\x06\0\x02\0\x12\x04.\x020\x03\x1a\x9e\x02\x20Li\ + sts\x20operations\x20that\x20match\x20the\x20specified\x20filter\x20in\ + \x20the\x20request.\x20If\x20the\n\x20server\x20doesn't\x20support\x20th\ + is\x20method,\x20it\x20returns\x20`UNIMPLEMENTED`.\n\n\x20NOTE:\x20the\ + \x20`name`\x20binding\x20below\x20allows\x20API\x20services\x20to\x20ove\ + rride\x20the\x20binding\n\x20to\x20use\x20different\x20resource\x20name\ + \x20schemes,\x20such\x20as\x20`users/*/operations`.\n\n\x0c\n\x05\x06\0\ + \x02\0\x01\x12\x03.\x06\x14\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03.\x15*\n\ + \x0c\n\x05\x06\0\x02\0\x03\x12\x03.5K\n\x0c\n\x05\x06\0\x02\0\x04\x12\ + \x03/\x04@\n\x10\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x03/\x04@\n\xaf\ + \x01\n\x04\x06\0\x02\x01\x12\x045\x027\x03\x1a\xa0\x01\x20Gets\x20the\ + \x20latest\x20state\x20of\x20a\x20long-running\x20operation.\x20\x20Clie\ + nts\x20can\x20use\x20this\n\x20method\x20to\x20poll\x20the\x20operation\ + \x20result\x20at\x20intervals\x20as\x20recommended\x20by\x20the\x20API\n\ + \x20service.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x035\x06\x12\n\x0c\n\ + \x05\x06\0\x02\x01\x02\x12\x035\x13&\n\x0c\n\x05\x06\0\x02\x01\x03\x12\ + \x0351:\n\x0c\n\x05\x06\0\x02\x01\x04\x12\x036\x04C\n\x10\n\t\x06\0\x02\ + \x01\x04\xb0\xca\xbc\"\x12\x036\x04C\n\x85\x02\n\x04\x06\0\x02\x02\x12\ + \x04=\x02?\x03\x1a\xf6\x01\x20Deletes\x20a\x20long-running\x20operation.\ + \x20This\x20method\x20indicates\x20that\x20the\x20client\x20is\n\x20no\ + \x20longer\x20interested\x20in\x20the\x20operation\x20result.\x20It\x20d\ + oes\x20not\x20cancel\x20the\n\x20operation.\x20If\x20the\x20server\x20do\ + esn't\x20support\x20this\x20method,\x20it\x20returns\n\x20`google.rpc.Co\ + de.UNIMPLEMENTED`.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03=\x06\x15\n\ + \x0c\n\x05\x06\0\x02\x02\x02\x12\x03=\x16,\n\x0c\n\x05\x06\0\x02\x02\x03\ + \x12\x03=7L\n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03>\x04F\n\x10\n\t\x06\0\ + \x02\x02\x04\xb0\xca\xbc\"\x12\x03>\x04F\n\xd4\x05\n\x04\x06\0\x02\x03\ + \x12\x04K\x02M\x03\x1a\xc5\x05\x20Starts\x20asynchronous\x20cancellation\ + \x20on\x20a\x20long-running\x20operation.\x20\x20The\x20server\n\x20make\ + s\x20a\x20best\x20effort\x20to\x20cancel\x20the\x20operation,\x20but\x20\ + success\x20is\x20not\n\x20guaranteed.\x20\x20If\x20the\x20server\x20does\ + n't\x20support\x20this\x20method,\x20it\x20returns\n\x20`google.rpc.Code\ + .UNIMPLEMENTED`.\x20\x20Clients\x20can\x20use\n\x20[Operations.GetOperat\ + ion][google.longrunning.Operations.GetOperation]\x20or\n\x20other\x20met\ + hods\x20to\x20check\x20whether\x20the\x20cancellation\x20succeeded\x20or\ + \x20whether\x20the\n\x20operation\x20completed\x20despite\x20cancellatio\ + n.\x20On\x20successful\x20cancellation,\n\x20the\x20operation\x20is\x20n\ + ot\x20deleted;\x20instead,\x20it\x20becomes\x20an\x20operation\x20with\n\ + \x20an\x20[Operation.error][google.longrunning.Operation.error]\x20value\ + \x20with\x20a\x20[google.rpc.Status.code][google.rpc.Status.code]\x20of\ + \x201,\n\x20corresponding\x20to\x20`Code.CANCELLED`.\n\n\x0c\n\x05\x06\0\ + \x02\x03\x01\x12\x03K\x06\x15\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03K\x16\ + ,\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03K7L\n\x0c\n\x05\x06\0\x02\x03\x04\ + \x12\x03L\x04U\n\x10\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x03L\x04U\n\ + j\n\x02\x04\0\x12\x04R\0t\x01\x1a^\x20This\x20resource\x20represents\x20\ + a\x20long-running\x20operation\x20that\x20is\x20the\x20result\x20of\x20a\ + \n\x20network\x20API\x20call.\n\n\n\n\x03\x04\0\x01\x12\x03R\x08\x11\n\ + \xdd\x01\n\x04\x04\0\x02\0\x12\x03V\x02\x12\x1a\xcf\x01\x20The\x20server\ + -assigned\x20name,\x20which\x20is\x20only\x20unique\x20within\x20the\x20\ + same\x20service\x20that\n\x20originally\x20returns\x20it.\x20If\x20you\ + \x20use\x20the\x20default\x20HTTP\x20mapping,\x20the\n\x20`name`\x20shou\ + ld\x20have\x20the\x20format\x20of\x20`operations/some/unique/name`.\n\n\ + \r\n\x05\x04\0\x02\0\x04\x12\x04V\x02R\x13\n\x0c\n\x05\x04\0\x02\0\x05\ + \x12\x03V\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03V\t\r\n\x0c\n\x05\ + \x04\0\x02\0\x03\x12\x03V\x10\x11\n\xac\x02\n\x04\x04\0\x02\x01\x12\x03\ + \\\x02#\x1a\x9e\x02\x20Service-specific\x20metadata\x20associated\x20wit\ + h\x20the\x20operation.\x20\x20It\x20typically\n\x20contains\x20progress\ + \x20information\x20and\x20common\x20metadata\x20such\x20as\x20create\x20\ + time.\n\x20Some\x20services\x20might\x20not\x20provide\x20such\x20metada\ + ta.\x20\x20Any\x20method\x20that\x20returns\x20a\n\x20long-running\x20op\ + eration\x20should\x20document\x20the\x20metadata\x20type,\x20if\x20any.\ + \n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04\\\x02V\x12\n\x0c\n\x05\x04\0\x02\ + \x01\x06\x12\x03\\\x02\x15\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\\\x16\ + \x1e\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\\!\"\n\xab\x01\n\x04\x04\0\ + \x02\x02\x12\x03a\x02\x10\x1a\x9d\x01\x20If\x20the\x20value\x20is\x20`fa\ + lse`,\x20it\x20means\x20the\x20operation\x20is\x20still\x20in\x20progres\ + s.\n\x20If\x20true,\x20the\x20operation\x20is\x20completed,\x20and\x20ei\ + ther\x20`error`\x20or\x20`response`\x20is\n\x20available.\n\n\r\n\x05\ + \x04\0\x02\x02\x04\x12\x04a\x02\\#\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03\ + a\x02\x06\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03a\x07\x0b\n\x0c\n\x05\x04\ + \0\x02\x02\x03\x12\x03a\x0e\x0f\n\xdd\x01\n\x04\x04\0\x08\0\x12\x04f\x02\ + s\x03\x1a\xce\x01\x20The\x20operation\x20result,\x20which\x20can\x20be\ + \x20either\x20an\x20`error`\x20or\x20a\x20valid\x20`response`.\n\x20If\ + \x20`done`\x20==\x20`false`,\x20neither\x20`error`\x20nor\x20`response`\ + \x20is\x20set.\n\x20If\x20`done`\x20==\x20`true`,\x20exactly\x20one\x20o\ + f\x20`error`\x20or\x20`response`\x20is\x20set.\n\n\x0c\n\x05\x04\0\x08\0\ + \x01\x12\x03f\x08\x0e\nT\n\x04\x04\0\x02\x03\x12\x03h\x04\x20\x1aG\x20Th\ + e\x20error\x20result\x20of\x20the\x20operation\x20in\x20case\x20of\x20fa\ + ilure\x20or\x20cancellation.\n\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03h\ + \x04\x15\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03h\x16\x1b\n\x0c\n\x05\x04\ + \0\x02\x03\x03\x12\x03h\x1e\x1f\n\x83\x04\n\x04\x04\0\x02\x04\x12\x03r\ + \x04%\x1a\xf5\x03\x20The\x20normal\x20response\x20of\x20the\x20operation\ + \x20in\x20case\x20of\x20success.\x20\x20If\x20the\x20original\n\x20metho\ + d\x20returns\x20no\x20data\x20on\x20success,\x20such\x20as\x20`Delete`,\ + \x20the\x20response\x20is\n\x20`google.protobuf.Empty`.\x20\x20If\x20the\ + \x20original\x20method\x20is\x20standard\n\x20`Get`/`Create`/`Update`,\ + \x20the\x20response\x20should\x20be\x20the\x20resource.\x20\x20For\x20ot\ + her\n\x20methods,\x20the\x20response\x20should\x20have\x20the\x20type\ + \x20`XxxResponse`,\x20where\x20`Xxx`\n\x20is\x20the\x20original\x20metho\ + d\x20name.\x20\x20For\x20example,\x20if\x20the\x20original\x20method\x20\ + name\n\x20is\x20`TakeSnapshot()`,\x20the\x20inferred\x20response\x20type\ + \x20is\n\x20`TakeSnapshotResponse`.\n\n\x0c\n\x05\x04\0\x02\x04\x06\x12\ + \x03r\x04\x17\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03r\x18\x20\n\x0c\n\x05\ + \x04\0\x02\x04\x03\x12\x03r#$\nl\n\x02\x04\x01\x12\x04w\0z\x01\x1a`\x20T\ + he\x20request\x20message\x20for\x20[Operations.GetOperation][google.long\ + running.Operations.GetOperation].\n\n\n\n\x03\x04\x01\x01\x12\x03w\x08\ + \x1b\n2\n\x04\x04\x01\x02\0\x12\x03y\x02\x12\x1a%\x20The\x20name\x20of\ + \x20the\x20operation\x20resource.\n\n\r\n\x05\x04\x01\x02\0\x04\x12\x04y\ + \x02w\x1d\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03y\x02\x08\n\x0c\n\x05\x04\ + \x01\x02\0\x01\x12\x03y\t\r\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03y\x10\ + \x11\nq\n\x02\x04\x02\x12\x05}\0\x89\x01\x01\x1ad\x20The\x20request\x20m\ + essage\x20for\x20[Operations.ListOperations][google.longrunning.Operatio\ + ns.ListOperations].\n\n\n\n\x03\x04\x02\x01\x12\x03}\x08\x1d\n4\n\x04\ + \x04\x02\x02\0\x12\x03\x7f\x02\x12\x1a'\x20The\x20name\x20of\x20the\x20o\ + peration\x20collection.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04\x7f\x02}\ + \x1f\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\x7f\x02\x08\n\x0c\n\x05\x04\ + \x02\x02\0\x01\x12\x03\x7f\t\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\x7f\ + \x10\x11\n)\n\x04\x04\x02\x02\x01\x12\x04\x82\x01\x02\x14\x1a\x1b\x20The\ + \x20standard\x20list\x20filter.\n\n\x0e\n\x05\x04\x02\x02\x01\x04\x12\ + \x05\x82\x01\x02\x7f\x12\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\x82\x01\ + \x02\x08\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\x82\x01\t\x0f\n\r\n\x05\ + \x04\x02\x02\x01\x03\x12\x04\x82\x01\x12\x13\n,\n\x04\x04\x02\x02\x02\ + \x12\x04\x85\x01\x02\x16\x1a\x1e\x20The\x20standard\x20list\x20page\x20s\ + ize.\n\n\x0f\n\x05\x04\x02\x02\x02\x04\x12\x06\x85\x01\x02\x82\x01\x14\n\ + \r\n\x05\x04\x02\x02\x02\x05\x12\x04\x85\x01\x02\x07\n\r\n\x05\x04\x02\ + \x02\x02\x01\x12\x04\x85\x01\x08\x11\n\r\n\x05\x04\x02\x02\x02\x03\x12\ + \x04\x85\x01\x14\x15\n-\n\x04\x04\x02\x02\x03\x12\x04\x88\x01\x02\x18\ + \x1a\x1f\x20The\x20standard\x20list\x20page\x20token.\n\n\x0f\n\x05\x04\ + \x02\x02\x03\x04\x12\x06\x88\x01\x02\x85\x01\x16\n\r\n\x05\x04\x02\x02\ + \x03\x05\x12\x04\x88\x01\x02\x08\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\ + \x88\x01\t\x13\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\x88\x01\x16\x17\ns\ + \n\x02\x04\x03\x12\x06\x8c\x01\0\x92\x01\x01\x1ae\x20The\x20response\x20\ + message\x20for\x20[Operations.ListOperations][google.longrunning.Operati\ + ons.ListOperations].\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x8c\x01\x08\x1e\n\ + V\n\x04\x04\x03\x02\0\x12\x04\x8e\x01\x02$\x1aH\x20A\x20list\x20of\x20op\ + erations\x20that\x20matches\x20the\x20specified\x20filter\x20in\x20the\ + \x20request.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\x8e\x01\x02\n\n\r\n\ + \x05\x04\x03\x02\0\x06\x12\x04\x8e\x01\x0b\x14\n\r\n\x05\x04\x03\x02\0\ + \x01\x12\x04\x8e\x01\x15\x1f\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x8e\x01\ + \"#\n2\n\x04\x04\x03\x02\x01\x12\x04\x91\x01\x02\x1d\x1a$\x20The\x20stan\ + dard\x20List\x20next-page\x20token.\n\n\x0f\n\x05\x04\x03\x02\x01\x04\ + \x12\x06\x91\x01\x02\x8e\x01$\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\x91\ + \x01\x02\x08\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x91\x01\t\x18\n\r\n\ + \x05\x04\x03\x02\x01\x03\x12\x04\x91\x01\x1b\x1c\nt\n\x02\x04\x04\x12\ + \x06\x95\x01\0\x98\x01\x01\x1af\x20The\x20request\x20message\x20for\x20[\ + Operations.CancelOperation][google.longrunning.Operations.CancelOperatio\ + n].\n\n\x0b\n\x03\x04\x04\x01\x12\x04\x95\x01\x08\x1e\nC\n\x04\x04\x04\ + \x02\0\x12\x04\x97\x01\x02\x12\x1a5\x20The\x20name\x20of\x20the\x20opera\ + tion\x20resource\x20to\x20be\x20cancelled.\n\n\x0f\n\x05\x04\x04\x02\0\ + \x04\x12\x06\x97\x01\x02\x95\x01\x20\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\ + \x97\x01\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\x97\x01\t\r\n\r\n\ + \x05\x04\x04\x02\0\x03\x12\x04\x97\x01\x10\x11\nt\n\x02\x04\x05\x12\x06\ + \x9b\x01\0\x9e\x01\x01\x1af\x20The\x20request\x20message\x20for\x20[Oper\ + ations.DeleteOperation][google.longrunning.Operations.DeleteOperation].\ + \n\n\x0b\n\x03\x04\x05\x01\x12\x04\x9b\x01\x08\x1e\nA\n\x04\x04\x05\x02\ + \0\x12\x04\x9d\x01\x02\x12\x1a3\x20The\x20name\x20of\x20the\x20operation\ + \x20resource\x20to\x20be\x20deleted.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\ + \x06\x9d\x01\x02\x9b\x01\x20\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x9d\x01\ + \x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x9d\x01\t\r\n\r\n\x05\x04\ + \x05\x02\0\x03\x12\x04\x9d\x01\x10\x11b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations_grpc.rs new file mode 100644 index 00000000..5510eea5 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/longrunning/operations_grpc.rs @@ -0,0 +1,155 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_OPERATIONS_LIST_OPERATIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.longrunning.Operations/ListOperations", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_OPERATIONS_GET_OPERATION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.longrunning.Operations/GetOperation", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_OPERATIONS_DELETE_OPERATION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.longrunning.Operations/DeleteOperation", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_OPERATIONS_CANCEL_OPERATION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.longrunning.Operations/CancelOperation", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct OperationsClient { + client: ::grpcio::Client, +} + +impl OperationsClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + OperationsClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn list_operations_opt(&self, req: &super::operations::ListOperationsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_OPERATIONS_LIST_OPERATIONS, req, opt) + } + + pub fn list_operations(&self, req: &super::operations::ListOperationsRequest) -> ::grpcio::Result { + self.list_operations_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_operations_async_opt(&self, req: &super::operations::ListOperationsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_OPERATIONS_LIST_OPERATIONS, req, opt) + } + + pub fn list_operations_async(&self, req: &super::operations::ListOperationsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_operations_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_operation_opt(&self, req: &super::operations::GetOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_OPERATIONS_GET_OPERATION, req, opt) + } + + pub fn get_operation(&self, req: &super::operations::GetOperationRequest) -> ::grpcio::Result { + self.get_operation_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_operation_async_opt(&self, req: &super::operations::GetOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_OPERATIONS_GET_OPERATION, req, opt) + } + + pub fn get_operation_async(&self, req: &super::operations::GetOperationRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_operation_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_operation_opt(&self, req: &super::operations::DeleteOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_OPERATIONS_DELETE_OPERATION, req, opt) + } + + pub fn delete_operation(&self, req: &super::operations::DeleteOperationRequest) -> ::grpcio::Result { + self.delete_operation_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_operation_async_opt(&self, req: &super::operations::DeleteOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_OPERATIONS_DELETE_OPERATION, req, opt) + } + + pub fn delete_operation_async(&self, req: &super::operations::DeleteOperationRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_operation_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn cancel_operation_opt(&self, req: &super::operations::CancelOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_OPERATIONS_CANCEL_OPERATION, req, opt) + } + + pub fn cancel_operation(&self, req: &super::operations::CancelOperationRequest) -> ::grpcio::Result { + self.cancel_operation_opt(req, ::grpcio::CallOption::default()) + } + + pub fn cancel_operation_async_opt(&self, req: &super::operations::CancelOperationRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_OPERATIONS_CANCEL_OPERATION, req, opt) + } + + pub fn cancel_operation_async(&self, req: &super::operations::CancelOperationRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.cancel_operation_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Operations { + fn list_operations(&mut self, ctx: ::grpcio::RpcContext, req: super::operations::ListOperationsRequest, sink: ::grpcio::UnarySink); + fn get_operation(&mut self, ctx: ::grpcio::RpcContext, req: super::operations::GetOperationRequest, sink: ::grpcio::UnarySink); + fn delete_operation(&mut self, ctx: ::grpcio::RpcContext, req: super::operations::DeleteOperationRequest, sink: ::grpcio::UnarySink); + fn cancel_operation(&mut self, ctx: ::grpcio::RpcContext, req: super::operations::CancelOperationRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_operations(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_OPERATIONS_LIST_OPERATIONS, move |ctx, req, resp| { + instance.list_operations(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_OPERATIONS_GET_OPERATION, move |ctx, req, resp| { + instance.get_operation(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_OPERATIONS_DELETE_OPERATION, move |ctx, req, resp| { + instance.delete_operation(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_OPERATIONS_CANCEL_OPERATION, move |ctx, req, resp| { + instance.cancel_operation(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/mod.rs new file mode 100644 index 00000000..21e5d4f7 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/mod.rs @@ -0,0 +1,2 @@ +pub mod v1; +pub mod v1beta2; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/mod.rs new file mode 100644 index 00000000..a7f02e63 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/mod.rs @@ -0,0 +1,4 @@ +pub mod pubsub; +pub mod pubsub_grpc; + +pub(crate) use crate::empty; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub.rs new file mode 100644 index 00000000..9b423774 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub.rs @@ -0,0 +1,10230 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/pubsub/v1/pubsub.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct MessageStoragePolicy { + // message fields + pub allowed_persistence_regions: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MessageStoragePolicy { + fn default() -> &'a MessageStoragePolicy { + ::default_instance() + } +} + +impl MessageStoragePolicy { + pub fn new() -> MessageStoragePolicy { + ::std::default::Default::default() + } + + // repeated string allowed_persistence_regions = 1; + + + pub fn get_allowed_persistence_regions(&self) -> &[::std::string::String] { + &self.allowed_persistence_regions + } + pub fn clear_allowed_persistence_regions(&mut self) { + self.allowed_persistence_regions.clear(); + } + + // Param is passed by value, moved + pub fn set_allowed_persistence_regions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.allowed_persistence_regions = v; + } + + // Mutable pointer to the field. + pub fn mut_allowed_persistence_regions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.allowed_persistence_regions + } + + // Take field + pub fn take_allowed_persistence_regions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.allowed_persistence_regions, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MessageStoragePolicy { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.allowed_persistence_regions)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.allowed_persistence_regions { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.allowed_persistence_regions { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MessageStoragePolicy { + MessageStoragePolicy::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "allowed_persistence_regions", + |m: &MessageStoragePolicy| { &m.allowed_persistence_regions }, + |m: &mut MessageStoragePolicy| { &mut m.allowed_persistence_regions }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "MessageStoragePolicy", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MessageStoragePolicy { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const MessageStoragePolicy, + }; + unsafe { + instance.get(MessageStoragePolicy::new) + } + } +} + +impl ::protobuf::Clear for MessageStoragePolicy { + fn clear(&mut self) { + self.allowed_persistence_regions.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MessageStoragePolicy { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MessageStoragePolicy { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Topic { + // message fields + pub name: ::std::string::String, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + pub message_storage_policy: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Topic { + fn default() -> &'a Topic { + ::default_instance() + } +} + +impl Topic { + pub fn new() -> Topic { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1.Topic.LabelsEntry labels = 2; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } + + // .google.pubsub.v1.MessageStoragePolicy message_storage_policy = 3; + + + pub fn get_message_storage_policy(&self) -> &MessageStoragePolicy { + self.message_storage_policy.as_ref().unwrap_or_else(|| MessageStoragePolicy::default_instance()) + } + pub fn clear_message_storage_policy(&mut self) { + self.message_storage_policy.clear(); + } + + pub fn has_message_storage_policy(&self) -> bool { + self.message_storage_policy.is_some() + } + + // Param is passed by value, moved + pub fn set_message_storage_policy(&mut self, v: MessageStoragePolicy) { + self.message_storage_policy = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message_storage_policy(&mut self) -> &mut MessageStoragePolicy { + if self.message_storage_policy.is_none() { + self.message_storage_policy.set_default(); + } + self.message_storage_policy.as_mut().unwrap() + } + + // Take field + pub fn take_message_storage_policy(&mut self) -> MessageStoragePolicy { + self.message_storage_policy.take().unwrap_or_else(|| MessageStoragePolicy::new()) + } +} + +impl ::protobuf::Message for Topic { + fn is_initialized(&self) -> bool { + for v in &self.message_storage_policy { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message_storage_policy)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels); + if let Some(ref v) = self.message_storage_policy.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels, os)?; + if let Some(ref v) = self.message_storage_policy.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Topic { + Topic::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Topic| { &m.name }, + |m: &mut Topic| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Topic| { &m.labels }, + |m: &mut Topic| { &mut m.labels }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "message_storage_policy", + |m: &Topic| { &m.message_storage_policy }, + |m: &mut Topic| { &mut m.message_storage_policy }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Topic", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Topic { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Topic, + }; + unsafe { + instance.get(Topic::new) + } + } +} + +impl ::protobuf::Clear for Topic { + fn clear(&mut self) { + self.name.clear(); + self.labels.clear(); + self.message_storage_policy.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Topic { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Topic { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PubsubMessage { + // message fields + pub data: ::std::vec::Vec, + pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + pub message_id: ::std::string::String, + pub publish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PubsubMessage { + fn default() -> &'a PubsubMessage { + ::default_instance() + } +} + +impl PubsubMessage { + pub fn new() -> PubsubMessage { + ::std::default::Default::default() + } + + // bytes data = 1; + + + pub fn get_data(&self) -> &[u8] { + &self.data + } + pub fn clear_data(&mut self) { + self.data.clear(); + } + + // Param is passed by value, moved + pub fn set_data(&mut self, v: ::std::vec::Vec) { + self.data = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_data(&mut self) -> &mut ::std::vec::Vec { + &mut self.data + } + + // Take field + pub fn take_data(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.data, ::std::vec::Vec::new()) + } + + // repeated .google.pubsub.v1.PubsubMessage.AttributesEntry attributes = 2; + + + pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.attributes + } + pub fn clear_attributes(&mut self) { + self.attributes.clear(); + } + + // Param is passed by value, moved + pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.attributes = v; + } + + // Mutable pointer to the field. + pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.attributes + } + + // Take field + pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new()) + } + + // string message_id = 3; + + + pub fn get_message_id(&self) -> &str { + &self.message_id + } + pub fn clear_message_id(&mut self) { + self.message_id.clear(); + } + + // Param is passed by value, moved + pub fn set_message_id(&mut self, v: ::std::string::String) { + self.message_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message_id(&mut self) -> &mut ::std::string::String { + &mut self.message_id + } + + // Take field + pub fn take_message_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.message_id, ::std::string::String::new()) + } + + // .google.protobuf.Timestamp publish_time = 4; + + + pub fn get_publish_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.publish_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_publish_time(&mut self) { + self.publish_time.clear(); + } + + pub fn has_publish_time(&self) -> bool { + self.publish_time.is_some() + } + + // Param is passed by value, moved + pub fn set_publish_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.publish_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_publish_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.publish_time.is_none() { + self.publish_time.set_default(); + } + self.publish_time.as_mut().unwrap() + } + + // Take field + pub fn take_publish_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.publish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for PubsubMessage { + fn is_initialized(&self) -> bool { + for v in &self.publish_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.data)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message_id)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.publish_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.data.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.data); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes); + if !self.message_id.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.message_id); + } + if let Some(ref v) = self.publish_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.data.is_empty() { + os.write_bytes(1, &self.data)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, os)?; + if !self.message_id.is_empty() { + os.write_string(3, &self.message_id)?; + } + if let Some(ref v) = self.publish_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PubsubMessage { + PubsubMessage::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "data", + |m: &PubsubMessage| { &m.data }, + |m: &mut PubsubMessage| { &mut m.data }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "attributes", + |m: &PubsubMessage| { &m.attributes }, + |m: &mut PubsubMessage| { &mut m.attributes }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message_id", + |m: &PubsubMessage| { &m.message_id }, + |m: &mut PubsubMessage| { &mut m.message_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "publish_time", + |m: &PubsubMessage| { &m.publish_time }, + |m: &mut PubsubMessage| { &mut m.publish_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PubsubMessage", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PubsubMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PubsubMessage, + }; + unsafe { + instance.get(PubsubMessage::new) + } + } +} + +impl ::protobuf::Clear for PubsubMessage { + fn clear(&mut self) { + self.data.clear(); + self.attributes.clear(); + self.message_id.clear(); + self.publish_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PubsubMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PubsubMessage { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetTopicRequest { + // message fields + pub topic: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetTopicRequest { + fn default() -> &'a GetTopicRequest { + ::default_instance() + } +} + +impl GetTopicRequest { + pub fn new() -> GetTopicRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetTopicRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetTopicRequest { + GetTopicRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &GetTopicRequest| { &m.topic }, + |m: &mut GetTopicRequest| { &mut m.topic }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetTopicRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetTopicRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetTopicRequest, + }; + unsafe { + instance.get(GetTopicRequest::new) + } + } +} + +impl ::protobuf::Clear for GetTopicRequest { + fn clear(&mut self) { + self.topic.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetTopicRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetTopicRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateTopicRequest { + // message fields + pub topic: ::protobuf::SingularPtrField, + pub update_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateTopicRequest { + fn default() -> &'a UpdateTopicRequest { + ::default_instance() + } +} + +impl UpdateTopicRequest { + pub fn new() -> UpdateTopicRequest { + ::std::default::Default::default() + } + + // .google.pubsub.v1.Topic topic = 1; + + + pub fn get_topic(&self) -> &Topic { + self.topic.as_ref().unwrap_or_else(|| Topic::default_instance()) + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + pub fn has_topic(&self) -> bool { + self.topic.is_some() + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: Topic) { + self.topic = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut Topic { + if self.topic.is_none() { + self.topic.set_default(); + } + self.topic.as_mut().unwrap() + } + + // Take field + pub fn take_topic(&mut self) -> Topic { + self.topic.take().unwrap_or_else(|| Topic::new()) + } + + // .google.protobuf.FieldMask update_mask = 2; + + + pub fn get_update_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.update_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_update_mask(&mut self) { + self.update_mask.clear(); + } + + pub fn has_update_mask(&self) -> bool { + self.update_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_update_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.update_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_update_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.update_mask.is_none() { + self.update_mask.set_default(); + } + self.update_mask.as_mut().unwrap() + } + + // Take field + pub fn take_update_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.update_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } +} + +impl ::protobuf::Message for UpdateTopicRequest { + fn is_initialized(&self) -> bool { + for v in &self.topic { + if !v.is_initialized() { + return false; + } + }; + for v in &self.update_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_mask)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.topic.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.update_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.topic.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.update_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateTopicRequest { + UpdateTopicRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "topic", + |m: &UpdateTopicRequest| { &m.topic }, + |m: &mut UpdateTopicRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "update_mask", + |m: &UpdateTopicRequest| { &m.update_mask }, + |m: &mut UpdateTopicRequest| { &mut m.update_mask }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateTopicRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateTopicRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateTopicRequest, + }; + unsafe { + instance.get(UpdateTopicRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateTopicRequest { + fn clear(&mut self) { + self.topic.clear(); + self.update_mask.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateTopicRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateTopicRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PublishRequest { + // message fields + pub topic: ::std::string::String, + pub messages: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PublishRequest { + fn default() -> &'a PublishRequest { + ::default_instance() + } +} + +impl PublishRequest { + pub fn new() -> PublishRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1.PubsubMessage messages = 2; + + + pub fn get_messages(&self) -> &[PubsubMessage] { + &self.messages + } + pub fn clear_messages(&mut self) { + self.messages.clear(); + } + + // Param is passed by value, moved + pub fn set_messages(&mut self, v: ::protobuf::RepeatedField) { + self.messages = v; + } + + // Mutable pointer to the field. + pub fn mut_messages(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.messages + } + + // Take field + pub fn take_messages(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.messages, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PublishRequest { + fn is_initialized(&self) -> bool { + for v in &self.messages { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.messages)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + for value in &self.messages { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + for v in &self.messages { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PublishRequest { + PublishRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &PublishRequest| { &m.topic }, + |m: &mut PublishRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "messages", + |m: &PublishRequest| { &m.messages }, + |m: &mut PublishRequest| { &mut m.messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PublishRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PublishRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PublishRequest, + }; + unsafe { + instance.get(PublishRequest::new) + } + } +} + +impl ::protobuf::Clear for PublishRequest { + fn clear(&mut self) { + self.topic.clear(); + self.messages.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PublishRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PublishRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PublishResponse { + // message fields + pub message_ids: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PublishResponse { + fn default() -> &'a PublishResponse { + ::default_instance() + } +} + +impl PublishResponse { + pub fn new() -> PublishResponse { + ::std::default::Default::default() + } + + // repeated string message_ids = 1; + + + pub fn get_message_ids(&self) -> &[::std::string::String] { + &self.message_ids + } + pub fn clear_message_ids(&mut self) { + self.message_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_message_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.message_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_message_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.message_ids + } + + // Take field + pub fn take_message_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.message_ids, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PublishResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.message_ids)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.message_ids { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.message_ids { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PublishResponse { + PublishResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message_ids", + |m: &PublishResponse| { &m.message_ids }, + |m: &mut PublishResponse| { &mut m.message_ids }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PublishResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PublishResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PublishResponse, + }; + unsafe { + instance.get(PublishResponse::new) + } + } +} + +impl ::protobuf::Clear for PublishResponse { + fn clear(&mut self) { + self.message_ids.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PublishResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PublishResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicsRequest { + // message fields + pub project: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicsRequest { + fn default() -> &'a ListTopicsRequest { + ::default_instance() + } +} + +impl ListTopicsRequest { + pub fn new() -> ListTopicsRequest { + ::std::default::Default::default() + } + + // string project = 1; + + + pub fn get_project(&self) -> &str { + &self.project + } + pub fn clear_project(&mut self) { + self.project.clear(); + } + + // Param is passed by value, moved + pub fn set_project(&mut self, v: ::std::string::String) { + self.project = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_project(&mut self) -> &mut ::std::string::String { + &mut self.project + } + + // Take field + pub fn take_project(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.project, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.project)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.project.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.project); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.project.is_empty() { + os.write_string(1, &self.project)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicsRequest { + ListTopicsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "project", + |m: &ListTopicsRequest| { &m.project }, + |m: &mut ListTopicsRequest| { &mut m.project }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTopicsRequest| { &m.page_size }, + |m: &mut ListTopicsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTopicsRequest| { &m.page_token }, + |m: &mut ListTopicsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicsRequest, + }; + unsafe { + instance.get(ListTopicsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTopicsRequest { + fn clear(&mut self) { + self.project.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicsResponse { + // message fields + pub topics: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicsResponse { + fn default() -> &'a ListTopicsResponse { + ::default_instance() + } +} + +impl ListTopicsResponse { + pub fn new() -> ListTopicsResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1.Topic topics = 1; + + + pub fn get_topics(&self) -> &[Topic] { + &self.topics + } + pub fn clear_topics(&mut self) { + self.topics.clear(); + } + + // Param is passed by value, moved + pub fn set_topics(&mut self, v: ::protobuf::RepeatedField) { + self.topics = v; + } + + // Mutable pointer to the field. + pub fn mut_topics(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.topics + } + + // Take field + pub fn take_topics(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.topics, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicsResponse { + fn is_initialized(&self) -> bool { + for v in &self.topics { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.topics)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.topics { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.topics { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicsResponse { + ListTopicsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "topics", + |m: &ListTopicsResponse| { &m.topics }, + |m: &mut ListTopicsResponse| { &mut m.topics }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTopicsResponse| { &m.next_page_token }, + |m: &mut ListTopicsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicsResponse, + }; + unsafe { + instance.get(ListTopicsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTopicsResponse { + fn clear(&mut self) { + self.topics.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSubscriptionsRequest { + // message fields + pub topic: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSubscriptionsRequest { + fn default() -> &'a ListTopicSubscriptionsRequest { + ::default_instance() + } +} + +impl ListTopicSubscriptionsRequest { + pub fn new() -> ListTopicSubscriptionsRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSubscriptionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSubscriptionsRequest { + ListTopicSubscriptionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &ListTopicSubscriptionsRequest| { &m.topic }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTopicSubscriptionsRequest| { &m.page_size }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTopicSubscriptionsRequest| { &m.page_token }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSubscriptionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSubscriptionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSubscriptionsRequest, + }; + unsafe { + instance.get(ListTopicSubscriptionsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSubscriptionsRequest { + fn clear(&mut self) { + self.topic.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSubscriptionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSubscriptionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSubscriptionsResponse { + // message fields + pub subscriptions: ::protobuf::RepeatedField<::std::string::String>, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSubscriptionsResponse { + fn default() -> &'a ListTopicSubscriptionsResponse { + ::default_instance() + } +} + +impl ListTopicSubscriptionsResponse { + pub fn new() -> ListTopicSubscriptionsResponse { + ::std::default::Default::default() + } + + // repeated string subscriptions = 1; + + + pub fn get_subscriptions(&self) -> &[::std::string::String] { + &self.subscriptions + } + pub fn clear_subscriptions(&mut self) { + self.subscriptions.clear(); + } + + // Param is passed by value, moved + pub fn set_subscriptions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.subscriptions = v; + } + + // Mutable pointer to the field. + pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.subscriptions + } + + // Take field + pub fn take_subscriptions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.subscriptions, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSubscriptionsResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.subscriptions)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.subscriptions { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.subscriptions { + os.write_string(1, &v)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSubscriptionsResponse { + ListTopicSubscriptionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscriptions", + |m: &ListTopicSubscriptionsResponse| { &m.subscriptions }, + |m: &mut ListTopicSubscriptionsResponse| { &mut m.subscriptions }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTopicSubscriptionsResponse| { &m.next_page_token }, + |m: &mut ListTopicSubscriptionsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSubscriptionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSubscriptionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSubscriptionsResponse, + }; + unsafe { + instance.get(ListTopicSubscriptionsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSubscriptionsResponse { + fn clear(&mut self) { + self.subscriptions.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSubscriptionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSubscriptionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSnapshotsRequest { + // message fields + pub topic: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSnapshotsRequest { + fn default() -> &'a ListTopicSnapshotsRequest { + ::default_instance() + } +} + +impl ListTopicSnapshotsRequest { + pub fn new() -> ListTopicSnapshotsRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSnapshotsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSnapshotsRequest { + ListTopicSnapshotsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &ListTopicSnapshotsRequest| { &m.topic }, + |m: &mut ListTopicSnapshotsRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTopicSnapshotsRequest| { &m.page_size }, + |m: &mut ListTopicSnapshotsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTopicSnapshotsRequest| { &m.page_token }, + |m: &mut ListTopicSnapshotsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSnapshotsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSnapshotsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSnapshotsRequest, + }; + unsafe { + instance.get(ListTopicSnapshotsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSnapshotsRequest { + fn clear(&mut self) { + self.topic.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSnapshotsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSnapshotsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSnapshotsResponse { + // message fields + pub snapshots: ::protobuf::RepeatedField<::std::string::String>, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSnapshotsResponse { + fn default() -> &'a ListTopicSnapshotsResponse { + ::default_instance() + } +} + +impl ListTopicSnapshotsResponse { + pub fn new() -> ListTopicSnapshotsResponse { + ::std::default::Default::default() + } + + // repeated string snapshots = 1; + + + pub fn get_snapshots(&self) -> &[::std::string::String] { + &self.snapshots + } + pub fn clear_snapshots(&mut self) { + self.snapshots.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshots(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.snapshots = v; + } + + // Mutable pointer to the field. + pub fn mut_snapshots(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.snapshots + } + + // Take field + pub fn take_snapshots(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.snapshots, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSnapshotsResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.snapshots)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.snapshots { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.snapshots { + os.write_string(1, &v)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSnapshotsResponse { + ListTopicSnapshotsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "snapshots", + |m: &ListTopicSnapshotsResponse| { &m.snapshots }, + |m: &mut ListTopicSnapshotsResponse| { &mut m.snapshots }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTopicSnapshotsResponse| { &m.next_page_token }, + |m: &mut ListTopicSnapshotsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSnapshotsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSnapshotsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSnapshotsResponse, + }; + unsafe { + instance.get(ListTopicSnapshotsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSnapshotsResponse { + fn clear(&mut self) { + self.snapshots.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSnapshotsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSnapshotsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteTopicRequest { + // message fields + pub topic: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteTopicRequest { + fn default() -> &'a DeleteTopicRequest { + ::default_instance() + } +} + +impl DeleteTopicRequest { + pub fn new() -> DeleteTopicRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteTopicRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteTopicRequest { + DeleteTopicRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &DeleteTopicRequest| { &m.topic }, + |m: &mut DeleteTopicRequest| { &mut m.topic }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteTopicRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteTopicRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteTopicRequest, + }; + unsafe { + instance.get(DeleteTopicRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteTopicRequest { + fn clear(&mut self) { + self.topic.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteTopicRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteTopicRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Subscription { + // message fields + pub name: ::std::string::String, + pub topic: ::std::string::String, + pub push_config: ::protobuf::SingularPtrField, + pub ack_deadline_seconds: i32, + pub retain_acked_messages: bool, + pub message_retention_duration: ::protobuf::SingularPtrField<::protobuf::well_known_types::Duration>, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + pub expiration_policy: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Subscription { + fn default() -> &'a Subscription { + ::default_instance() + } +} + +impl Subscription { + pub fn new() -> Subscription { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string topic = 2; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // .google.pubsub.v1.PushConfig push_config = 4; + + + pub fn get_push_config(&self) -> &PushConfig { + self.push_config.as_ref().unwrap_or_else(|| PushConfig::default_instance()) + } + pub fn clear_push_config(&mut self) { + self.push_config.clear(); + } + + pub fn has_push_config(&self) -> bool { + self.push_config.is_some() + } + + // Param is passed by value, moved + pub fn set_push_config(&mut self, v: PushConfig) { + self.push_config = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_config(&mut self) -> &mut PushConfig { + if self.push_config.is_none() { + self.push_config.set_default(); + } + self.push_config.as_mut().unwrap() + } + + // Take field + pub fn take_push_config(&mut self) -> PushConfig { + self.push_config.take().unwrap_or_else(|| PushConfig::new()) + } + + // int32 ack_deadline_seconds = 5; + + + pub fn get_ack_deadline_seconds(&self) -> i32 { + self.ack_deadline_seconds + } + pub fn clear_ack_deadline_seconds(&mut self) { + self.ack_deadline_seconds = 0; + } + + // Param is passed by value, moved + pub fn set_ack_deadline_seconds(&mut self, v: i32) { + self.ack_deadline_seconds = v; + } + + // bool retain_acked_messages = 7; + + + pub fn get_retain_acked_messages(&self) -> bool { + self.retain_acked_messages + } + pub fn clear_retain_acked_messages(&mut self) { + self.retain_acked_messages = false; + } + + // Param is passed by value, moved + pub fn set_retain_acked_messages(&mut self, v: bool) { + self.retain_acked_messages = v; + } + + // .google.protobuf.Duration message_retention_duration = 8; + + + pub fn get_message_retention_duration(&self) -> &::protobuf::well_known_types::Duration { + self.message_retention_duration.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Duration::default_instance()) + } + pub fn clear_message_retention_duration(&mut self) { + self.message_retention_duration.clear(); + } + + pub fn has_message_retention_duration(&self) -> bool { + self.message_retention_duration.is_some() + } + + // Param is passed by value, moved + pub fn set_message_retention_duration(&mut self, v: ::protobuf::well_known_types::Duration) { + self.message_retention_duration = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message_retention_duration(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if self.message_retention_duration.is_none() { + self.message_retention_duration.set_default(); + } + self.message_retention_duration.as_mut().unwrap() + } + + // Take field + pub fn take_message_retention_duration(&mut self) -> ::protobuf::well_known_types::Duration { + self.message_retention_duration.take().unwrap_or_else(|| ::protobuf::well_known_types::Duration::new()) + } + + // repeated .google.pubsub.v1.Subscription.LabelsEntry labels = 9; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } + + // .google.pubsub.v1.ExpirationPolicy expiration_policy = 11; + + + pub fn get_expiration_policy(&self) -> &ExpirationPolicy { + self.expiration_policy.as_ref().unwrap_or_else(|| ExpirationPolicy::default_instance()) + } + pub fn clear_expiration_policy(&mut self) { + self.expiration_policy.clear(); + } + + pub fn has_expiration_policy(&self) -> bool { + self.expiration_policy.is_some() + } + + // Param is passed by value, moved + pub fn set_expiration_policy(&mut self, v: ExpirationPolicy) { + self.expiration_policy = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_expiration_policy(&mut self) -> &mut ExpirationPolicy { + if self.expiration_policy.is_none() { + self.expiration_policy.set_default(); + } + self.expiration_policy.as_mut().unwrap() + } + + // Take field + pub fn take_expiration_policy(&mut self) -> ExpirationPolicy { + self.expiration_policy.take().unwrap_or_else(|| ExpirationPolicy::new()) + } +} + +impl ::protobuf::Message for Subscription { + fn is_initialized(&self) -> bool { + for v in &self.push_config { + if !v.is_initialized() { + return false; + } + }; + for v in &self.message_retention_duration { + if !v.is_initialized() { + return false; + } + }; + for v in &self.expiration_policy { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.ack_deadline_seconds = tmp; + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.retain_acked_messages = tmp; + }, + 8 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message_retention_duration)?; + }, + 9 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + 11 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.expiration_policy)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.topic); + } + if let Some(ref v) = self.push_config.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.ack_deadline_seconds != 0 { + my_size += ::protobuf::rt::value_size(5, self.ack_deadline_seconds, ::protobuf::wire_format::WireTypeVarint); + } + if self.retain_acked_messages != false { + my_size += 2; + } + if let Some(ref v) = self.message_retention_duration.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(9, &self.labels); + if let Some(ref v) = self.expiration_policy.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.topic.is_empty() { + os.write_string(2, &self.topic)?; + } + if let Some(ref v) = self.push_config.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.ack_deadline_seconds != 0 { + os.write_int32(5, self.ack_deadline_seconds)?; + } + if self.retain_acked_messages != false { + os.write_bool(7, self.retain_acked_messages)?; + } + if let Some(ref v) = self.message_retention_duration.as_ref() { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(9, &self.labels, os)?; + if let Some(ref v) = self.expiration_policy.as_ref() { + os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Subscription { + Subscription::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Subscription| { &m.name }, + |m: &mut Subscription| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &Subscription| { &m.topic }, + |m: &mut Subscription| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "push_config", + |m: &Subscription| { &m.push_config }, + |m: &mut Subscription| { &mut m.push_config }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "ack_deadline_seconds", + |m: &Subscription| { &m.ack_deadline_seconds }, + |m: &mut Subscription| { &mut m.ack_deadline_seconds }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "retain_acked_messages", + |m: &Subscription| { &m.retain_acked_messages }, + |m: &mut Subscription| { &mut m.retain_acked_messages }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Duration>>( + "message_retention_duration", + |m: &Subscription| { &m.message_retention_duration }, + |m: &mut Subscription| { &mut m.message_retention_duration }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Subscription| { &m.labels }, + |m: &mut Subscription| { &mut m.labels }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "expiration_policy", + |m: &Subscription| { &m.expiration_policy }, + |m: &mut Subscription| { &mut m.expiration_policy }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Subscription", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Subscription { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Subscription, + }; + unsafe { + instance.get(Subscription::new) + } + } +} + +impl ::protobuf::Clear for Subscription { + fn clear(&mut self) { + self.name.clear(); + self.topic.clear(); + self.push_config.clear(); + self.ack_deadline_seconds = 0; + self.retain_acked_messages = false; + self.message_retention_duration.clear(); + self.labels.clear(); + self.expiration_policy.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Subscription { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Subscription { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ExpirationPolicy { + // message fields + pub ttl: ::protobuf::SingularPtrField<::protobuf::well_known_types::Duration>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ExpirationPolicy { + fn default() -> &'a ExpirationPolicy { + ::default_instance() + } +} + +impl ExpirationPolicy { + pub fn new() -> ExpirationPolicy { + ::std::default::Default::default() + } + + // .google.protobuf.Duration ttl = 1; + + + pub fn get_ttl(&self) -> &::protobuf::well_known_types::Duration { + self.ttl.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Duration::default_instance()) + } + pub fn clear_ttl(&mut self) { + self.ttl.clear(); + } + + pub fn has_ttl(&self) -> bool { + self.ttl.is_some() + } + + // Param is passed by value, moved + pub fn set_ttl(&mut self, v: ::protobuf::well_known_types::Duration) { + self.ttl = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ttl(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if self.ttl.is_none() { + self.ttl.set_default(); + } + self.ttl.as_mut().unwrap() + } + + // Take field + pub fn take_ttl(&mut self) -> ::protobuf::well_known_types::Duration { + self.ttl.take().unwrap_or_else(|| ::protobuf::well_known_types::Duration::new()) + } +} + +impl ::protobuf::Message for ExpirationPolicy { + fn is_initialized(&self) -> bool { + for v in &self.ttl { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ttl)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.ttl.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.ttl.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ExpirationPolicy { + ExpirationPolicy::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Duration>>( + "ttl", + |m: &ExpirationPolicy| { &m.ttl }, + |m: &mut ExpirationPolicy| { &mut m.ttl }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ExpirationPolicy", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ExpirationPolicy { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ExpirationPolicy, + }; + unsafe { + instance.get(ExpirationPolicy::new) + } + } +} + +impl ::protobuf::Clear for ExpirationPolicy { + fn clear(&mut self) { + self.ttl.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ExpirationPolicy { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ExpirationPolicy { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PushConfig { + // message fields + pub push_endpoint: ::std::string::String, + pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PushConfig { + fn default() -> &'a PushConfig { + ::default_instance() + } +} + +impl PushConfig { + pub fn new() -> PushConfig { + ::std::default::Default::default() + } + + // string push_endpoint = 1; + + + pub fn get_push_endpoint(&self) -> &str { + &self.push_endpoint + } + pub fn clear_push_endpoint(&mut self) { + self.push_endpoint.clear(); + } + + // Param is passed by value, moved + pub fn set_push_endpoint(&mut self, v: ::std::string::String) { + self.push_endpoint = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_endpoint(&mut self) -> &mut ::std::string::String { + &mut self.push_endpoint + } + + // Take field + pub fn take_push_endpoint(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.push_endpoint, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1.PushConfig.AttributesEntry attributes = 2; + + + pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.attributes + } + pub fn clear_attributes(&mut self) { + self.attributes.clear(); + } + + // Param is passed by value, moved + pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.attributes = v; + } + + // Mutable pointer to the field. + pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.attributes + } + + // Take field + pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for PushConfig { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.push_endpoint)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.push_endpoint.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.push_endpoint); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.push_endpoint.is_empty() { + os.write_string(1, &self.push_endpoint)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PushConfig { + PushConfig::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "push_endpoint", + |m: &PushConfig| { &m.push_endpoint }, + |m: &mut PushConfig| { &mut m.push_endpoint }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "attributes", + |m: &PushConfig| { &m.attributes }, + |m: &mut PushConfig| { &mut m.attributes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PushConfig", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PushConfig { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PushConfig, + }; + unsafe { + instance.get(PushConfig::new) + } + } +} + +impl ::protobuf::Clear for PushConfig { + fn clear(&mut self) { + self.push_endpoint.clear(); + self.attributes.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PushConfig { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PushConfig { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReceivedMessage { + // message fields + pub ack_id: ::std::string::String, + pub message: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReceivedMessage { + fn default() -> &'a ReceivedMessage { + ::default_instance() + } +} + +impl ReceivedMessage { + pub fn new() -> ReceivedMessage { + ::std::default::Default::default() + } + + // string ack_id = 1; + + + pub fn get_ack_id(&self) -> &str { + &self.ack_id + } + pub fn clear_ack_id(&mut self) { + self.ack_id.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_id(&mut self, v: ::std::string::String) { + self.ack_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ack_id(&mut self) -> &mut ::std::string::String { + &mut self.ack_id + } + + // Take field + pub fn take_ack_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.ack_id, ::std::string::String::new()) + } + + // .google.pubsub.v1.PubsubMessage message = 2; + + + pub fn get_message(&self) -> &PubsubMessage { + self.message.as_ref().unwrap_or_else(|| PubsubMessage::default_instance()) + } + pub fn clear_message(&mut self) { + self.message.clear(); + } + + pub fn has_message(&self) -> bool { + self.message.is_some() + } + + // Param is passed by value, moved + pub fn set_message(&mut self, v: PubsubMessage) { + self.message = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message(&mut self) -> &mut PubsubMessage { + if self.message.is_none() { + self.message.set_default(); + } + self.message.as_mut().unwrap() + } + + // Take field + pub fn take_message(&mut self) -> PubsubMessage { + self.message.take().unwrap_or_else(|| PubsubMessage::new()) + } +} + +impl ::protobuf::Message for ReceivedMessage { + fn is_initialized(&self) -> bool { + for v in &self.message { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ack_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.ack_id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.ack_id); + } + if let Some(ref v) = self.message.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.ack_id.is_empty() { + os.write_string(1, &self.ack_id)?; + } + if let Some(ref v) = self.message.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReceivedMessage { + ReceivedMessage::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_id", + |m: &ReceivedMessage| { &m.ack_id }, + |m: &mut ReceivedMessage| { &mut m.ack_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "message", + |m: &ReceivedMessage| { &m.message }, + |m: &mut ReceivedMessage| { &mut m.message }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReceivedMessage", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReceivedMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReceivedMessage, + }; + unsafe { + instance.get(ReceivedMessage::new) + } + } +} + +impl ::protobuf::Clear for ReceivedMessage { + fn clear(&mut self) { + self.ack_id.clear(); + self.message.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReceivedMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReceivedMessage { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetSubscriptionRequest { + // message fields + pub subscription: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetSubscriptionRequest { + fn default() -> &'a GetSubscriptionRequest { + ::default_instance() + } +} + +impl GetSubscriptionRequest { + pub fn new() -> GetSubscriptionRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetSubscriptionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetSubscriptionRequest { + GetSubscriptionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &GetSubscriptionRequest| { &m.subscription }, + |m: &mut GetSubscriptionRequest| { &mut m.subscription }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetSubscriptionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetSubscriptionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetSubscriptionRequest, + }; + unsafe { + instance.get(GetSubscriptionRequest::new) + } + } +} + +impl ::protobuf::Clear for GetSubscriptionRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetSubscriptionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetSubscriptionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateSubscriptionRequest { + // message fields + pub subscription: ::protobuf::SingularPtrField, + pub update_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateSubscriptionRequest { + fn default() -> &'a UpdateSubscriptionRequest { + ::default_instance() + } +} + +impl UpdateSubscriptionRequest { + pub fn new() -> UpdateSubscriptionRequest { + ::std::default::Default::default() + } + + // .google.pubsub.v1.Subscription subscription = 1; + + + pub fn get_subscription(&self) -> &Subscription { + self.subscription.as_ref().unwrap_or_else(|| Subscription::default_instance()) + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + pub fn has_subscription(&self) -> bool { + self.subscription.is_some() + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: Subscription) { + self.subscription = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut Subscription { + if self.subscription.is_none() { + self.subscription.set_default(); + } + self.subscription.as_mut().unwrap() + } + + // Take field + pub fn take_subscription(&mut self) -> Subscription { + self.subscription.take().unwrap_or_else(|| Subscription::new()) + } + + // .google.protobuf.FieldMask update_mask = 2; + + + pub fn get_update_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.update_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_update_mask(&mut self) { + self.update_mask.clear(); + } + + pub fn has_update_mask(&self) -> bool { + self.update_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_update_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.update_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_update_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.update_mask.is_none() { + self.update_mask.set_default(); + } + self.update_mask.as_mut().unwrap() + } + + // Take field + pub fn take_update_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.update_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } +} + +impl ::protobuf::Message for UpdateSubscriptionRequest { + fn is_initialized(&self) -> bool { + for v in &self.subscription { + if !v.is_initialized() { + return false; + } + }; + for v in &self.update_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_mask)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.subscription.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.update_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.subscription.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.update_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateSubscriptionRequest { + UpdateSubscriptionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "subscription", + |m: &UpdateSubscriptionRequest| { &m.subscription }, + |m: &mut UpdateSubscriptionRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "update_mask", + |m: &UpdateSubscriptionRequest| { &m.update_mask }, + |m: &mut UpdateSubscriptionRequest| { &mut m.update_mask }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateSubscriptionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateSubscriptionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateSubscriptionRequest, + }; + unsafe { + instance.get(UpdateSubscriptionRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateSubscriptionRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.update_mask.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateSubscriptionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateSubscriptionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSubscriptionsRequest { + // message fields + pub project: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSubscriptionsRequest { + fn default() -> &'a ListSubscriptionsRequest { + ::default_instance() + } +} + +impl ListSubscriptionsRequest { + pub fn new() -> ListSubscriptionsRequest { + ::std::default::Default::default() + } + + // string project = 1; + + + pub fn get_project(&self) -> &str { + &self.project + } + pub fn clear_project(&mut self) { + self.project.clear(); + } + + // Param is passed by value, moved + pub fn set_project(&mut self, v: ::std::string::String) { + self.project = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_project(&mut self) -> &mut ::std::string::String { + &mut self.project + } + + // Take field + pub fn take_project(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.project, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSubscriptionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.project)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.project.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.project); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.project.is_empty() { + os.write_string(1, &self.project)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSubscriptionsRequest { + ListSubscriptionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "project", + |m: &ListSubscriptionsRequest| { &m.project }, + |m: &mut ListSubscriptionsRequest| { &mut m.project }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListSubscriptionsRequest| { &m.page_size }, + |m: &mut ListSubscriptionsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListSubscriptionsRequest| { &m.page_token }, + |m: &mut ListSubscriptionsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSubscriptionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSubscriptionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSubscriptionsRequest, + }; + unsafe { + instance.get(ListSubscriptionsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListSubscriptionsRequest { + fn clear(&mut self) { + self.project.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSubscriptionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSubscriptionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSubscriptionsResponse { + // message fields + pub subscriptions: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSubscriptionsResponse { + fn default() -> &'a ListSubscriptionsResponse { + ::default_instance() + } +} + +impl ListSubscriptionsResponse { + pub fn new() -> ListSubscriptionsResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1.Subscription subscriptions = 1; + + + pub fn get_subscriptions(&self) -> &[Subscription] { + &self.subscriptions + } + pub fn clear_subscriptions(&mut self) { + self.subscriptions.clear(); + } + + // Param is passed by value, moved + pub fn set_subscriptions(&mut self, v: ::protobuf::RepeatedField) { + self.subscriptions = v; + } + + // Mutable pointer to the field. + pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.subscriptions + } + + // Take field + pub fn take_subscriptions(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.subscriptions, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSubscriptionsResponse { + fn is_initialized(&self) -> bool { + for v in &self.subscriptions { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.subscriptions)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.subscriptions { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.subscriptions { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSubscriptionsResponse { + ListSubscriptionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "subscriptions", + |m: &ListSubscriptionsResponse| { &m.subscriptions }, + |m: &mut ListSubscriptionsResponse| { &mut m.subscriptions }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListSubscriptionsResponse| { &m.next_page_token }, + |m: &mut ListSubscriptionsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSubscriptionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSubscriptionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSubscriptionsResponse, + }; + unsafe { + instance.get(ListSubscriptionsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListSubscriptionsResponse { + fn clear(&mut self) { + self.subscriptions.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSubscriptionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSubscriptionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteSubscriptionRequest { + // message fields + pub subscription: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteSubscriptionRequest { + fn default() -> &'a DeleteSubscriptionRequest { + ::default_instance() + } +} + +impl DeleteSubscriptionRequest { + pub fn new() -> DeleteSubscriptionRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteSubscriptionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteSubscriptionRequest { + DeleteSubscriptionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &DeleteSubscriptionRequest| { &m.subscription }, + |m: &mut DeleteSubscriptionRequest| { &mut m.subscription }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteSubscriptionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteSubscriptionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteSubscriptionRequest, + }; + unsafe { + instance.get(DeleteSubscriptionRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteSubscriptionRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteSubscriptionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteSubscriptionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyPushConfigRequest { + // message fields + pub subscription: ::std::string::String, + pub push_config: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyPushConfigRequest { + fn default() -> &'a ModifyPushConfigRequest { + ::default_instance() + } +} + +impl ModifyPushConfigRequest { + pub fn new() -> ModifyPushConfigRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // .google.pubsub.v1.PushConfig push_config = 2; + + + pub fn get_push_config(&self) -> &PushConfig { + self.push_config.as_ref().unwrap_or_else(|| PushConfig::default_instance()) + } + pub fn clear_push_config(&mut self) { + self.push_config.clear(); + } + + pub fn has_push_config(&self) -> bool { + self.push_config.is_some() + } + + // Param is passed by value, moved + pub fn set_push_config(&mut self, v: PushConfig) { + self.push_config = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_config(&mut self) -> &mut PushConfig { + if self.push_config.is_none() { + self.push_config.set_default(); + } + self.push_config.as_mut().unwrap() + } + + // Take field + pub fn take_push_config(&mut self) -> PushConfig { + self.push_config.take().unwrap_or_else(|| PushConfig::new()) + } +} + +impl ::protobuf::Message for ModifyPushConfigRequest { + fn is_initialized(&self) -> bool { + for v in &self.push_config { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if let Some(ref v) = self.push_config.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if let Some(ref v) = self.push_config.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyPushConfigRequest { + ModifyPushConfigRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &ModifyPushConfigRequest| { &m.subscription }, + |m: &mut ModifyPushConfigRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "push_config", + |m: &ModifyPushConfigRequest| { &m.push_config }, + |m: &mut ModifyPushConfigRequest| { &mut m.push_config }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyPushConfigRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyPushConfigRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyPushConfigRequest, + }; + unsafe { + instance.get(ModifyPushConfigRequest::new) + } + } +} + +impl ::protobuf::Clear for ModifyPushConfigRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.push_config.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyPushConfigRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyPushConfigRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PullRequest { + // message fields + pub subscription: ::std::string::String, + pub return_immediately: bool, + pub max_messages: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PullRequest { + fn default() -> &'a PullRequest { + ::default_instance() + } +} + +impl PullRequest { + pub fn new() -> PullRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // bool return_immediately = 2; + + + pub fn get_return_immediately(&self) -> bool { + self.return_immediately + } + pub fn clear_return_immediately(&mut self) { + self.return_immediately = false; + } + + // Param is passed by value, moved + pub fn set_return_immediately(&mut self, v: bool) { + self.return_immediately = v; + } + + // int32 max_messages = 3; + + + pub fn get_max_messages(&self) -> i32 { + self.max_messages + } + pub fn clear_max_messages(&mut self) { + self.max_messages = 0; + } + + // Param is passed by value, moved + pub fn set_max_messages(&mut self, v: i32) { + self.max_messages = v; + } +} + +impl ::protobuf::Message for PullRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.return_immediately = tmp; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.max_messages = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if self.return_immediately != false { + my_size += 2; + } + if self.max_messages != 0 { + my_size += ::protobuf::rt::value_size(3, self.max_messages, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if self.return_immediately != false { + os.write_bool(2, self.return_immediately)?; + } + if self.max_messages != 0 { + os.write_int32(3, self.max_messages)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PullRequest { + PullRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &PullRequest| { &m.subscription }, + |m: &mut PullRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "return_immediately", + |m: &PullRequest| { &m.return_immediately }, + |m: &mut PullRequest| { &mut m.return_immediately }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "max_messages", + |m: &PullRequest| { &m.max_messages }, + |m: &mut PullRequest| { &mut m.max_messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PullRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PullRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PullRequest, + }; + unsafe { + instance.get(PullRequest::new) + } + } +} + +impl ::protobuf::Clear for PullRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.return_immediately = false; + self.max_messages = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PullRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PullRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PullResponse { + // message fields + pub received_messages: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PullResponse { + fn default() -> &'a PullResponse { + ::default_instance() + } +} + +impl PullResponse { + pub fn new() -> PullResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1.ReceivedMessage received_messages = 1; + + + pub fn get_received_messages(&self) -> &[ReceivedMessage] { + &self.received_messages + } + pub fn clear_received_messages(&mut self) { + self.received_messages.clear(); + } + + // Param is passed by value, moved + pub fn set_received_messages(&mut self, v: ::protobuf::RepeatedField) { + self.received_messages = v; + } + + // Mutable pointer to the field. + pub fn mut_received_messages(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.received_messages + } + + // Take field + pub fn take_received_messages(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.received_messages, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PullResponse { + fn is_initialized(&self) -> bool { + for v in &self.received_messages { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.received_messages)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.received_messages { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.received_messages { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PullResponse { + PullResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "received_messages", + |m: &PullResponse| { &m.received_messages }, + |m: &mut PullResponse| { &mut m.received_messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PullResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PullResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PullResponse, + }; + unsafe { + instance.get(PullResponse::new) + } + } +} + +impl ::protobuf::Clear for PullResponse { + fn clear(&mut self) { + self.received_messages.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PullResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PullResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyAckDeadlineRequest { + // message fields + pub subscription: ::std::string::String, + pub ack_ids: ::protobuf::RepeatedField<::std::string::String>, + pub ack_deadline_seconds: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyAckDeadlineRequest { + fn default() -> &'a ModifyAckDeadlineRequest { + ::default_instance() + } +} + +impl ModifyAckDeadlineRequest { + pub fn new() -> ModifyAckDeadlineRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // repeated string ack_ids = 4; + + + pub fn get_ack_ids(&self) -> &[::std::string::String] { + &self.ack_ids + } + pub fn clear_ack_ids(&mut self) { + self.ack_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.ack_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.ack_ids + } + + // Take field + pub fn take_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.ack_ids, ::protobuf::RepeatedField::new()) + } + + // int32 ack_deadline_seconds = 3; + + + pub fn get_ack_deadline_seconds(&self) -> i32 { + self.ack_deadline_seconds + } + pub fn clear_ack_deadline_seconds(&mut self) { + self.ack_deadline_seconds = 0; + } + + // Param is passed by value, moved + pub fn set_ack_deadline_seconds(&mut self, v: i32) { + self.ack_deadline_seconds = v; + } +} + +impl ::protobuf::Message for ModifyAckDeadlineRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 4 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.ack_ids)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.ack_deadline_seconds = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + for value in &self.ack_ids { + my_size += ::protobuf::rt::string_size(4, &value); + }; + if self.ack_deadline_seconds != 0 { + my_size += ::protobuf::rt::value_size(3, self.ack_deadline_seconds, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + for v in &self.ack_ids { + os.write_string(4, &v)?; + }; + if self.ack_deadline_seconds != 0 { + os.write_int32(3, self.ack_deadline_seconds)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyAckDeadlineRequest { + ModifyAckDeadlineRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &ModifyAckDeadlineRequest| { &m.subscription }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_ids", + |m: &ModifyAckDeadlineRequest| { &m.ack_ids }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_ids }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "ack_deadline_seconds", + |m: &ModifyAckDeadlineRequest| { &m.ack_deadline_seconds }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_deadline_seconds }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyAckDeadlineRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyAckDeadlineRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyAckDeadlineRequest, + }; + unsafe { + instance.get(ModifyAckDeadlineRequest::new) + } + } +} + +impl ::protobuf::Clear for ModifyAckDeadlineRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.ack_ids.clear(); + self.ack_deadline_seconds = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyAckDeadlineRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyAckDeadlineRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct AcknowledgeRequest { + // message fields + pub subscription: ::std::string::String, + pub ack_ids: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a AcknowledgeRequest { + fn default() -> &'a AcknowledgeRequest { + ::default_instance() + } +} + +impl AcknowledgeRequest { + pub fn new() -> AcknowledgeRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // repeated string ack_ids = 2; + + + pub fn get_ack_ids(&self) -> &[::std::string::String] { + &self.ack_ids + } + pub fn clear_ack_ids(&mut self) { + self.ack_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.ack_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.ack_ids + } + + // Take field + pub fn take_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.ack_ids, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for AcknowledgeRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.ack_ids)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + for value in &self.ack_ids { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + for v in &self.ack_ids { + os.write_string(2, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> AcknowledgeRequest { + AcknowledgeRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &AcknowledgeRequest| { &m.subscription }, + |m: &mut AcknowledgeRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_ids", + |m: &AcknowledgeRequest| { &m.ack_ids }, + |m: &mut AcknowledgeRequest| { &mut m.ack_ids }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AcknowledgeRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static AcknowledgeRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AcknowledgeRequest, + }; + unsafe { + instance.get(AcknowledgeRequest::new) + } + } +} + +impl ::protobuf::Clear for AcknowledgeRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.ack_ids.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for AcknowledgeRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for AcknowledgeRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct StreamingPullRequest { + // message fields + pub subscription: ::std::string::String, + pub ack_ids: ::protobuf::RepeatedField<::std::string::String>, + pub modify_deadline_seconds: ::std::vec::Vec, + pub modify_deadline_ack_ids: ::protobuf::RepeatedField<::std::string::String>, + pub stream_ack_deadline_seconds: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a StreamingPullRequest { + fn default() -> &'a StreamingPullRequest { + ::default_instance() + } +} + +impl StreamingPullRequest { + pub fn new() -> StreamingPullRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // repeated string ack_ids = 2; + + + pub fn get_ack_ids(&self) -> &[::std::string::String] { + &self.ack_ids + } + pub fn clear_ack_ids(&mut self) { + self.ack_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.ack_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.ack_ids + } + + // Take field + pub fn take_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.ack_ids, ::protobuf::RepeatedField::new()) + } + + // repeated int32 modify_deadline_seconds = 3; + + + pub fn get_modify_deadline_seconds(&self) -> &[i32] { + &self.modify_deadline_seconds + } + pub fn clear_modify_deadline_seconds(&mut self) { + self.modify_deadline_seconds.clear(); + } + + // Param is passed by value, moved + pub fn set_modify_deadline_seconds(&mut self, v: ::std::vec::Vec) { + self.modify_deadline_seconds = v; + } + + // Mutable pointer to the field. + pub fn mut_modify_deadline_seconds(&mut self) -> &mut ::std::vec::Vec { + &mut self.modify_deadline_seconds + } + + // Take field + pub fn take_modify_deadline_seconds(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.modify_deadline_seconds, ::std::vec::Vec::new()) + } + + // repeated string modify_deadline_ack_ids = 4; + + + pub fn get_modify_deadline_ack_ids(&self) -> &[::std::string::String] { + &self.modify_deadline_ack_ids + } + pub fn clear_modify_deadline_ack_ids(&mut self) { + self.modify_deadline_ack_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_modify_deadline_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.modify_deadline_ack_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_modify_deadline_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.modify_deadline_ack_ids + } + + // Take field + pub fn take_modify_deadline_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.modify_deadline_ack_ids, ::protobuf::RepeatedField::new()) + } + + // int32 stream_ack_deadline_seconds = 5; + + + pub fn get_stream_ack_deadline_seconds(&self) -> i32 { + self.stream_ack_deadline_seconds + } + pub fn clear_stream_ack_deadline_seconds(&mut self) { + self.stream_ack_deadline_seconds = 0; + } + + // Param is passed by value, moved + pub fn set_stream_ack_deadline_seconds(&mut self, v: i32) { + self.stream_ack_deadline_seconds = v; + } +} + +impl ::protobuf::Message for StreamingPullRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.ack_ids)?; + }, + 3 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.modify_deadline_seconds)?; + }, + 4 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.modify_deadline_ack_ids)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.stream_ack_deadline_seconds = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + for value in &self.ack_ids { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.modify_deadline_seconds { + my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.modify_deadline_ack_ids { + my_size += ::protobuf::rt::string_size(4, &value); + }; + if self.stream_ack_deadline_seconds != 0 { + my_size += ::protobuf::rt::value_size(5, self.stream_ack_deadline_seconds, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + for v in &self.ack_ids { + os.write_string(2, &v)?; + }; + for v in &self.modify_deadline_seconds { + os.write_int32(3, *v)?; + }; + for v in &self.modify_deadline_ack_ids { + os.write_string(4, &v)?; + }; + if self.stream_ack_deadline_seconds != 0 { + os.write_int32(5, self.stream_ack_deadline_seconds)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> StreamingPullRequest { + StreamingPullRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &StreamingPullRequest| { &m.subscription }, + |m: &mut StreamingPullRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_ids", + |m: &StreamingPullRequest| { &m.ack_ids }, + |m: &mut StreamingPullRequest| { &mut m.ack_ids }, + )); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "modify_deadline_seconds", + |m: &StreamingPullRequest| { &m.modify_deadline_seconds }, + |m: &mut StreamingPullRequest| { &mut m.modify_deadline_seconds }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "modify_deadline_ack_ids", + |m: &StreamingPullRequest| { &m.modify_deadline_ack_ids }, + |m: &mut StreamingPullRequest| { &mut m.modify_deadline_ack_ids }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "stream_ack_deadline_seconds", + |m: &StreamingPullRequest| { &m.stream_ack_deadline_seconds }, + |m: &mut StreamingPullRequest| { &mut m.stream_ack_deadline_seconds }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "StreamingPullRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static StreamingPullRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const StreamingPullRequest, + }; + unsafe { + instance.get(StreamingPullRequest::new) + } + } +} + +impl ::protobuf::Clear for StreamingPullRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.ack_ids.clear(); + self.modify_deadline_seconds.clear(); + self.modify_deadline_ack_ids.clear(); + self.stream_ack_deadline_seconds = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for StreamingPullRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for StreamingPullRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct StreamingPullResponse { + // message fields + pub received_messages: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a StreamingPullResponse { + fn default() -> &'a StreamingPullResponse { + ::default_instance() + } +} + +impl StreamingPullResponse { + pub fn new() -> StreamingPullResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1.ReceivedMessage received_messages = 1; + + + pub fn get_received_messages(&self) -> &[ReceivedMessage] { + &self.received_messages + } + pub fn clear_received_messages(&mut self) { + self.received_messages.clear(); + } + + // Param is passed by value, moved + pub fn set_received_messages(&mut self, v: ::protobuf::RepeatedField) { + self.received_messages = v; + } + + // Mutable pointer to the field. + pub fn mut_received_messages(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.received_messages + } + + // Take field + pub fn take_received_messages(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.received_messages, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for StreamingPullResponse { + fn is_initialized(&self) -> bool { + for v in &self.received_messages { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.received_messages)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.received_messages { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.received_messages { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> StreamingPullResponse { + StreamingPullResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "received_messages", + |m: &StreamingPullResponse| { &m.received_messages }, + |m: &mut StreamingPullResponse| { &mut m.received_messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "StreamingPullResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static StreamingPullResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const StreamingPullResponse, + }; + unsafe { + instance.get(StreamingPullResponse::new) + } + } +} + +impl ::protobuf::Clear for StreamingPullResponse { + fn clear(&mut self) { + self.received_messages.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for StreamingPullResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for StreamingPullResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateSnapshotRequest { + // message fields + pub name: ::std::string::String, + pub subscription: ::std::string::String, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateSnapshotRequest { + fn default() -> &'a CreateSnapshotRequest { + ::default_instance() + } +} + +impl CreateSnapshotRequest { + pub fn new() -> CreateSnapshotRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string subscription = 2; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1.CreateSnapshotRequest.LabelsEntry labels = 3; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for CreateSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 3 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.subscription); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(3, &self.labels); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.subscription.is_empty() { + os.write_string(2, &self.subscription)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(3, &self.labels, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateSnapshotRequest { + CreateSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CreateSnapshotRequest| { &m.name }, + |m: &mut CreateSnapshotRequest| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &CreateSnapshotRequest| { &m.subscription }, + |m: &mut CreateSnapshotRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &CreateSnapshotRequest| { &m.labels }, + |m: &mut CreateSnapshotRequest| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateSnapshotRequest, + }; + unsafe { + instance.get(CreateSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateSnapshotRequest { + fn clear(&mut self) { + self.name.clear(); + self.subscription.clear(); + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateSnapshotRequest { + // message fields + pub snapshot: ::protobuf::SingularPtrField, + pub update_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateSnapshotRequest { + fn default() -> &'a UpdateSnapshotRequest { + ::default_instance() + } +} + +impl UpdateSnapshotRequest { + pub fn new() -> UpdateSnapshotRequest { + ::std::default::Default::default() + } + + // .google.pubsub.v1.Snapshot snapshot = 1; + + + pub fn get_snapshot(&self) -> &Snapshot { + self.snapshot.as_ref().unwrap_or_else(|| Snapshot::default_instance()) + } + pub fn clear_snapshot(&mut self) { + self.snapshot.clear(); + } + + pub fn has_snapshot(&self) -> bool { + self.snapshot.is_some() + } + + // Param is passed by value, moved + pub fn set_snapshot(&mut self, v: Snapshot) { + self.snapshot = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_snapshot(&mut self) -> &mut Snapshot { + if self.snapshot.is_none() { + self.snapshot.set_default(); + } + self.snapshot.as_mut().unwrap() + } + + // Take field + pub fn take_snapshot(&mut self) -> Snapshot { + self.snapshot.take().unwrap_or_else(|| Snapshot::new()) + } + + // .google.protobuf.FieldMask update_mask = 2; + + + pub fn get_update_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.update_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_update_mask(&mut self) { + self.update_mask.clear(); + } + + pub fn has_update_mask(&self) -> bool { + self.update_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_update_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.update_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_update_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.update_mask.is_none() { + self.update_mask.set_default(); + } + self.update_mask.as_mut().unwrap() + } + + // Take field + pub fn take_update_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.update_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } +} + +impl ::protobuf::Message for UpdateSnapshotRequest { + fn is_initialized(&self) -> bool { + for v in &self.snapshot { + if !v.is_initialized() { + return false; + } + }; + for v in &self.update_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.snapshot)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.update_mask)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.snapshot.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.update_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.snapshot.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.update_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateSnapshotRequest { + UpdateSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "snapshot", + |m: &UpdateSnapshotRequest| { &m.snapshot }, + |m: &mut UpdateSnapshotRequest| { &mut m.snapshot }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "update_mask", + |m: &UpdateSnapshotRequest| { &m.update_mask }, + |m: &mut UpdateSnapshotRequest| { &mut m.update_mask }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateSnapshotRequest, + }; + unsafe { + instance.get(UpdateSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateSnapshotRequest { + fn clear(&mut self) { + self.snapshot.clear(); + self.update_mask.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Snapshot { + // message fields + pub name: ::std::string::String, + pub topic: ::std::string::String, + pub expire_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Snapshot { + fn default() -> &'a Snapshot { + ::default_instance() + } +} + +impl Snapshot { + pub fn new() -> Snapshot { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string topic = 2; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // .google.protobuf.Timestamp expire_time = 3; + + + pub fn get_expire_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.expire_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_expire_time(&mut self) { + self.expire_time.clear(); + } + + pub fn has_expire_time(&self) -> bool { + self.expire_time.is_some() + } + + // Param is passed by value, moved + pub fn set_expire_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.expire_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_expire_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.expire_time.is_none() { + self.expire_time.set_default(); + } + self.expire_time.as_mut().unwrap() + } + + // Take field + pub fn take_expire_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.expire_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // repeated .google.pubsub.v1.Snapshot.LabelsEntry labels = 4; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for Snapshot { + fn is_initialized(&self) -> bool { + for v in &self.expire_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.expire_time)?; + }, + 4 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.topic); + } + if let Some(ref v) = self.expire_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(4, &self.labels); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.topic.is_empty() { + os.write_string(2, &self.topic)?; + } + if let Some(ref v) = self.expire_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(4, &self.labels, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Snapshot { + Snapshot::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Snapshot| { &m.name }, + |m: &mut Snapshot| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &Snapshot| { &m.topic }, + |m: &mut Snapshot| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "expire_time", + |m: &Snapshot| { &m.expire_time }, + |m: &mut Snapshot| { &mut m.expire_time }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Snapshot| { &m.labels }, + |m: &mut Snapshot| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Snapshot", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Snapshot { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Snapshot, + }; + unsafe { + instance.get(Snapshot::new) + } + } +} + +impl ::protobuf::Clear for Snapshot { + fn clear(&mut self) { + self.name.clear(); + self.topic.clear(); + self.expire_time.clear(); + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Snapshot { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Snapshot { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetSnapshotRequest { + // message fields + pub snapshot: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetSnapshotRequest { + fn default() -> &'a GetSnapshotRequest { + ::default_instance() + } +} + +impl GetSnapshotRequest { + pub fn new() -> GetSnapshotRequest { + ::std::default::Default::default() + } + + // string snapshot = 1; + + + pub fn get_snapshot(&self) -> &str { + &self.snapshot + } + pub fn clear_snapshot(&mut self) { + self.snapshot.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshot(&mut self, v: ::std::string::String) { + self.snapshot = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_snapshot(&mut self) -> &mut ::std::string::String { + &mut self.snapshot + } + + // Take field + pub fn take_snapshot(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.snapshot, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.snapshot)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.snapshot.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.snapshot); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.snapshot.is_empty() { + os.write_string(1, &self.snapshot)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetSnapshotRequest { + GetSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "snapshot", + |m: &GetSnapshotRequest| { &m.snapshot }, + |m: &mut GetSnapshotRequest| { &mut m.snapshot }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetSnapshotRequest, + }; + unsafe { + instance.get(GetSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for GetSnapshotRequest { + fn clear(&mut self) { + self.snapshot.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSnapshotsRequest { + // message fields + pub project: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSnapshotsRequest { + fn default() -> &'a ListSnapshotsRequest { + ::default_instance() + } +} + +impl ListSnapshotsRequest { + pub fn new() -> ListSnapshotsRequest { + ::std::default::Default::default() + } + + // string project = 1; + + + pub fn get_project(&self) -> &str { + &self.project + } + pub fn clear_project(&mut self) { + self.project.clear(); + } + + // Param is passed by value, moved + pub fn set_project(&mut self, v: ::std::string::String) { + self.project = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_project(&mut self) -> &mut ::std::string::String { + &mut self.project + } + + // Take field + pub fn take_project(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.project, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSnapshotsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.project)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.project.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.project); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.project.is_empty() { + os.write_string(1, &self.project)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSnapshotsRequest { + ListSnapshotsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "project", + |m: &ListSnapshotsRequest| { &m.project }, + |m: &mut ListSnapshotsRequest| { &mut m.project }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListSnapshotsRequest| { &m.page_size }, + |m: &mut ListSnapshotsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListSnapshotsRequest| { &m.page_token }, + |m: &mut ListSnapshotsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSnapshotsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSnapshotsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSnapshotsRequest, + }; + unsafe { + instance.get(ListSnapshotsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListSnapshotsRequest { + fn clear(&mut self) { + self.project.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSnapshotsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSnapshotsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSnapshotsResponse { + // message fields + pub snapshots: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSnapshotsResponse { + fn default() -> &'a ListSnapshotsResponse { + ::default_instance() + } +} + +impl ListSnapshotsResponse { + pub fn new() -> ListSnapshotsResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1.Snapshot snapshots = 1; + + + pub fn get_snapshots(&self) -> &[Snapshot] { + &self.snapshots + } + pub fn clear_snapshots(&mut self) { + self.snapshots.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshots(&mut self, v: ::protobuf::RepeatedField) { + self.snapshots = v; + } + + // Mutable pointer to the field. + pub fn mut_snapshots(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.snapshots + } + + // Take field + pub fn take_snapshots(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.snapshots, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSnapshotsResponse { + fn is_initialized(&self) -> bool { + for v in &self.snapshots { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.snapshots)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.snapshots { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.snapshots { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSnapshotsResponse { + ListSnapshotsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "snapshots", + |m: &ListSnapshotsResponse| { &m.snapshots }, + |m: &mut ListSnapshotsResponse| { &mut m.snapshots }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListSnapshotsResponse| { &m.next_page_token }, + |m: &mut ListSnapshotsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSnapshotsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSnapshotsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSnapshotsResponse, + }; + unsafe { + instance.get(ListSnapshotsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListSnapshotsResponse { + fn clear(&mut self) { + self.snapshots.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSnapshotsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSnapshotsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteSnapshotRequest { + // message fields + pub snapshot: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteSnapshotRequest { + fn default() -> &'a DeleteSnapshotRequest { + ::default_instance() + } +} + +impl DeleteSnapshotRequest { + pub fn new() -> DeleteSnapshotRequest { + ::std::default::Default::default() + } + + // string snapshot = 1; + + + pub fn get_snapshot(&self) -> &str { + &self.snapshot + } + pub fn clear_snapshot(&mut self) { + self.snapshot.clear(); + } + + // Param is passed by value, moved + pub fn set_snapshot(&mut self, v: ::std::string::String) { + self.snapshot = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_snapshot(&mut self) -> &mut ::std::string::String { + &mut self.snapshot + } + + // Take field + pub fn take_snapshot(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.snapshot, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteSnapshotRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.snapshot)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.snapshot.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.snapshot); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.snapshot.is_empty() { + os.write_string(1, &self.snapshot)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteSnapshotRequest { + DeleteSnapshotRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "snapshot", + |m: &DeleteSnapshotRequest| { &m.snapshot }, + |m: &mut DeleteSnapshotRequest| { &mut m.snapshot }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteSnapshotRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteSnapshotRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteSnapshotRequest, + }; + unsafe { + instance.get(DeleteSnapshotRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteSnapshotRequest { + fn clear(&mut self) { + self.snapshot.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteSnapshotRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteSnapshotRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SeekRequest { + // message fields + pub subscription: ::std::string::String, + // message oneof groups + pub target: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SeekRequest { + fn default() -> &'a SeekRequest { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum SeekRequest_oneof_target { + time(::protobuf::well_known_types::Timestamp), + snapshot(::std::string::String), +} + +impl SeekRequest { + pub fn new() -> SeekRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // .google.protobuf.Timestamp time = 2; + + + pub fn get_time(&self) -> &::protobuf::well_known_types::Timestamp { + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::time(ref v)) => v, + _ => ::protobuf::well_known_types::Timestamp::default_instance(), + } + } + pub fn clear_time(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_time(&self) -> bool { + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::time(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::time(v)) + } + + // Mutable pointer to the field. + pub fn mut_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if let ::std::option::Option::Some(SeekRequest_oneof_target::time(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::time(::protobuf::well_known_types::Timestamp::new())); + } + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::time(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + if self.has_time() { + match self.target.take() { + ::std::option::Option::Some(SeekRequest_oneof_target::time(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Timestamp::new() + } + } + + // string snapshot = 3; + + + pub fn get_snapshot(&self) -> &str { + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(ref v)) => v, + _ => "", + } + } + pub fn clear_snapshot(&mut self) { + self.target = ::std::option::Option::None; + } + + pub fn has_snapshot(&self) -> bool { + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_snapshot(&mut self, v: ::std::string::String) { + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(v)) + } + + // Mutable pointer to the field. + pub fn mut_snapshot(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(_)) = self.target { + } else { + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(::std::string::String::new())); + } + match self.target { + ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_snapshot(&mut self) -> ::std::string::String { + if self.has_snapshot() { + match self.target.take() { + ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } +} + +impl ::protobuf::Message for SeekRequest { + fn is_initialized(&self) -> bool { + if let Some(SeekRequest_oneof_target::time(ref v)) = self.target { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::time(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.target = ::std::option::Option::Some(SeekRequest_oneof_target::snapshot(is.read_string()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &SeekRequest_oneof_target::time(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &SeekRequest_oneof_target::snapshot(ref v) => { + my_size += ::protobuf::rt::string_size(3, &v); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if let ::std::option::Option::Some(ref v) = self.target { + match v { + &SeekRequest_oneof_target::time(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &SeekRequest_oneof_target::snapshot(ref v) => { + os.write_string(3, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SeekRequest { + SeekRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &SeekRequest| { &m.subscription }, + |m: &mut SeekRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Timestamp>( + "time", + SeekRequest::has_time, + SeekRequest::get_time, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "snapshot", + SeekRequest::has_snapshot, + SeekRequest::get_snapshot, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "SeekRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SeekRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SeekRequest, + }; + unsafe { + instance.get(SeekRequest::new) + } + } +} + +impl ::protobuf::Clear for SeekRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.target = ::std::option::Option::None; + self.target = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SeekRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SeekRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct SeekResponse { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SeekResponse { + fn default() -> &'a SeekResponse { + ::default_instance() + } +} + +impl SeekResponse { + pub fn new() -> SeekResponse { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for SeekResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SeekResponse { + SeekResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "SeekResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SeekResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const SeekResponse, + }; + unsafe { + instance.get(SeekResponse::new) + } + } +} + +impl ::protobuf::Clear for SeekResponse { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SeekResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SeekResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1dgoogle/pubsub/v1/pubsub.proto\x12\x10google.pubsub.v1\x1a\x1cgoogl\ + e/api/annotations.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1bgoo\ + gle/protobuf/empty.proto\x1a\x20google/protobuf/field_mask.proto\x1a\x1f\ + google/protobuf/timestamp.proto\"V\n\x14MessageStoragePolicy\x12>\n\x1ba\ + llowed_persistence_regions\x18\x01\x20\x03(\tR\x19allowedPersistenceRegi\ + ons\"\xf1\x01\n\x05Topic\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\ + \x12;\n\x06labels\x18\x02\x20\x03(\x0b2#.google.pubsub.v1.Topic.LabelsEn\ + tryR\x06labels\x12\\\n\x16message_storage_policy\x18\x03\x20\x01(\x0b2&.\ + google.pubsub.v1.MessageStoragePolicyR\x14messageStoragePolicy\x1a9\n\ + \x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\ + \x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"\x91\x02\n\rPubsubMess\ + age\x12\x12\n\x04data\x18\x01\x20\x01(\x0cR\x04data\x12O\n\nattributes\ + \x18\x02\x20\x03(\x0b2/.google.pubsub.v1.PubsubMessage.AttributesEntryR\ + \nattributes\x12\x1d\n\nmessage_id\x18\x03\x20\x01(\tR\tmessageId\x12=\n\ + \x0cpublish_time\x18\x04\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ + \x0bpublishTime\x1a=\n\x0fAttributesEntry\x12\x10\n\x03key\x18\x01\x20\ + \x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\ + \x01\"'\n\x0fGetTopicRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05t\ + opic\"\x80\x01\n\x12UpdateTopicRequest\x12-\n\x05topic\x18\x01\x20\x01(\ + \x0b2\x17.google.pubsub.v1.TopicR\x05topic\x12;\n\x0bupdate_mask\x18\x02\ + \x20\x01(\x0b2\x1a.google.protobuf.FieldMaskR\nupdateMask\"c\n\x0ePublis\ + hRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05topic\x12;\n\x08messa\ + ges\x18\x02\x20\x03(\x0b2\x1f.google.pubsub.v1.PubsubMessageR\x08message\ + s\"2\n\x0fPublishResponse\x12\x1f\n\x0bmessage_ids\x18\x01\x20\x03(\tR\n\ + messageIds\"i\n\x11ListTopicsRequest\x12\x18\n\x07project\x18\x01\x20\ + \x01(\tR\x07project\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSi\ + ze\x12\x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"m\n\x12ListTopi\ + csResponse\x12/\n\x06topics\x18\x01\x20\x03(\x0b2\x17.google.pubsub.v1.T\ + opicR\x06topics\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageT\ + oken\"q\n\x1dListTopicSubscriptionsRequest\x12\x14\n\x05topic\x18\x01\ + \x20\x01(\tR\x05topic\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08page\ + Size\x12\x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"n\n\x1eListTo\ + picSubscriptionsResponse\x12$\n\rsubscriptions\x18\x01\x20\x03(\tR\rsubs\ + criptions\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"\ + m\n\x19ListTopicSnapshotsRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\ + \x05topic\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\ + \n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"b\n\x1aListTopicSnapshots\ + Response\x12\x1c\n\tsnapshots\x18\x01\x20\x03(\tR\tsnapshots\x12&\n\x0fn\ + ext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"*\n\x12DeleteTopicReq\ + uest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05topic\"\x86\x04\n\x0cSubs\ + cription\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x14\n\x05topi\ + c\x18\x02\x20\x01(\tR\x05topic\x12=\n\x0bpush_config\x18\x04\x20\x01(\ + \x0b2\x1c.google.pubsub.v1.PushConfigR\npushConfig\x120\n\x14ack_deadlin\ + e_seconds\x18\x05\x20\x01(\x05R\x12ackDeadlineSeconds\x122\n\x15retain_a\ + cked_messages\x18\x07\x20\x01(\x08R\x13retainAckedMessages\x12W\n\x1ames\ + sage_retention_duration\x18\x08\x20\x01(\x0b2\x19.google.protobuf.Durati\ + onR\x18messageRetentionDuration\x12B\n\x06labels\x18\t\x20\x03(\x0b2*.go\ + ogle.pubsub.v1.Subscription.LabelsEntryR\x06labels\x12O\n\x11expiration_\ + policy\x18\x0b\x20\x01(\x0b2\".google.pubsub.v1.ExpirationPolicyR\x10exp\ + irationPolicy\x1a9\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\ + \x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"?\n\ + \x10ExpirationPolicy\x12+\n\x03ttl\x18\x01\x20\x01(\x0b2\x19.google.prot\ + obuf.DurationR\x03ttl\"\xbe\x01\n\nPushConfig\x12#\n\rpush_endpoint\x18\ + \x01\x20\x01(\tR\x0cpushEndpoint\x12L\n\nattributes\x18\x02\x20\x03(\x0b\ + 2,.google.pubsub.v1.PushConfig.AttributesEntryR\nattributes\x1a=\n\x0fAt\ + tributesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05v\ + alue\x18\x02\x20\x01(\tR\x05value:\x028\x01\"c\n\x0fReceivedMessage\x12\ + \x15\n\x06ack_id\x18\x01\x20\x01(\tR\x05ackId\x129\n\x07message\x18\x02\ + \x20\x01(\x0b2\x1f.google.pubsub.v1.PubsubMessageR\x07message\"<\n\x16Ge\ + tSubscriptionRequest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubs\ + cription\"\x9c\x01\n\x19UpdateSubscriptionRequest\x12B\n\x0csubscription\ + \x18\x01\x20\x01(\x0b2\x1e.google.pubsub.v1.SubscriptionR\x0csubscriptio\ + n\x12;\n\x0bupdate_mask\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.FieldM\ + askR\nupdateMask\"p\n\x18ListSubscriptionsRequest\x12\x18\n\x07project\ + \x18\x01\x20\x01(\tR\x07project\x12\x1b\n\tpage_size\x18\x02\x20\x01(\ + \x05R\x08pageSize\x12\x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\ + \x89\x01\n\x19ListSubscriptionsResponse\x12D\n\rsubscriptions\x18\x01\ + \x20\x03(\x0b2\x1e.google.pubsub.v1.SubscriptionR\rsubscriptions\x12&\n\ + \x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"?\n\x19DeleteSub\ + scriptionRequest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscrip\ + tion\"|\n\x17ModifyPushConfigRequest\x12\"\n\x0csubscription\x18\x01\x20\ + \x01(\tR\x0csubscription\x12=\n\x0bpush_config\x18\x02\x20\x01(\x0b2\x1c\ + .google.pubsub.v1.PushConfigR\npushConfig\"\x83\x01\n\x0bPullRequest\x12\ + \"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\x12-\n\x12retur\ + n_immediately\x18\x02\x20\x01(\x08R\x11returnImmediately\x12!\n\x0cmax_m\ + essages\x18\x03\x20\x01(\x05R\x0bmaxMessages\"^\n\x0cPullResponse\x12N\n\ + \x11received_messages\x18\x01\x20\x03(\x0b2!.google.pubsub.v1.ReceivedMe\ + ssageR\x10receivedMessages\"\x89\x01\n\x18ModifyAckDeadlineRequest\x12\"\ + \n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\x12\x17\n\x07ack_\ + ids\x18\x04\x20\x03(\tR\x06ackIds\x120\n\x14ack_deadline_seconds\x18\x03\ + \x20\x01(\x05R\x12ackDeadlineSeconds\"Q\n\x12AcknowledgeRequest\x12\"\n\ + \x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\x12\x17\n\x07ack_id\ + s\x18\x02\x20\x03(\tR\x06ackIds\"\x81\x02\n\x14StreamingPullRequest\x12\ + \"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\x12\x17\n\x07ac\ + k_ids\x18\x02\x20\x03(\tR\x06ackIds\x126\n\x17modify_deadline_seconds\ + \x18\x03\x20\x03(\x05R\x15modifyDeadlineSeconds\x125\n\x17modify_deadlin\ + e_ack_ids\x18\x04\x20\x03(\tR\x14modifyDeadlineAckIds\x12=\n\x1bstream_a\ + ck_deadline_seconds\x18\x05\x20\x01(\x05R\x18streamAckDeadlineSeconds\"g\ + \n\x15StreamingPullResponse\x12N\n\x11received_messages\x18\x01\x20\x03(\ + \x0b2!.google.pubsub.v1.ReceivedMessageR\x10receivedMessages\"\xd7\x01\n\ + \x15CreateSnapshotRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\ + \x12\"\n\x0csubscription\x18\x02\x20\x01(\tR\x0csubscription\x12K\n\x06l\ + abels\x18\x03\x20\x03(\x0b23.google.pubsub.v1.CreateSnapshotRequest.Labe\ + lsEntryR\x06labels\x1a9\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\ + \x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\ + \x01\"\x8c\x01\n\x15UpdateSnapshotRequest\x126\n\x08snapshot\x18\x01\x20\ + \x01(\x0b2\x1a.google.pubsub.v1.SnapshotR\x08snapshot\x12;\n\x0bupdate_m\ + ask\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.FieldMaskR\nupdateMask\"\ + \xec\x01\n\x08Snapshot\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\ + \x14\n\x05topic\x18\x02\x20\x01(\tR\x05topic\x12;\n\x0bexpire_time\x18\ + \x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nexpireTime\x12>\n\x06\ + labels\x18\x04\x20\x03(\x0b2&.google.pubsub.v1.Snapshot.LabelsEntryR\x06\ + labels\x1a9\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\ + \x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"0\n\x12GetSn\ + apshotRequest\x12\x1a\n\x08snapshot\x18\x01\x20\x01(\tR\x08snapshot\"l\n\ + \x14ListSnapshotsRequest\x12\x18\n\x07project\x18\x01\x20\x01(\tR\x07pro\ + ject\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\np\ + age_token\x18\x03\x20\x01(\tR\tpageToken\"y\n\x15ListSnapshotsResponse\ + \x128\n\tsnapshots\x18\x01\x20\x03(\x0b2\x1a.google.pubsub.v1.SnapshotR\ + \tsnapshots\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\ + \"3\n\x15DeleteSnapshotRequest\x12\x1a\n\x08snapshot\x18\x01\x20\x01(\tR\ + \x08snapshot\"\x8b\x01\n\x0bSeekRequest\x12\"\n\x0csubscription\x18\x01\ + \x20\x01(\tR\x0csubscription\x120\n\x04time\x18\x02\x20\x01(\x0b2\x1a.go\ + ogle.protobuf.TimestampH\0R\x04time\x12\x1c\n\x08snapshot\x18\x03\x20\ + \x01(\tH\0R\x08snapshotB\x08\n\x06target\"\x0e\n\x0cSeekResponse2\xbf\ + \x08\n\tPublisher\x12j\n\x0bCreateTopic\x12\x17.google.pubsub.v1.Topic\ + \x1a\x17.google.pubsub.v1.Topic\")\x82\xd3\xe4\x93\x02#\x1a\x1e/v1/{name\ + =projects/*/topics/*}:\x01*\x12}\n\x0bUpdateTopic\x12$.google.pubsub.v1.\ + UpdateTopicRequest\x1a\x17.google.pubsub.v1.Topic\"/\x82\xd3\xe4\x93\x02\ + )2$/v1/{topic.name=projects/*/topics/*}:\x01*\x12\x82\x01\n\x07Publish\ + \x12\x20.google.pubsub.v1.PublishRequest\x1a!.google.pubsub.v1.PublishRe\ + sponse\"2\x82\xd3\xe4\x93\x02,\"'/v1/{topic=projects/*/topics/*}:publish\ + :\x01*\x12o\n\x08GetTopic\x12!.google.pubsub.v1.GetTopicRequest\x1a\x17.\ + google.pubsub.v1.Topic\"'\x82\xd3\xe4\x93\x02!\x12\x1f/v1/{topic=project\ + s/*/topics/*}\x12\x80\x01\n\nListTopics\x12#.google.pubsub.v1.ListTopics\ + Request\x1a$.google.pubsub.v1.ListTopicsResponse\"'\x82\xd3\xe4\x93\x02!\ + \x12\x1f/v1/{project=projects/*}/topics\x12\xb2\x01\n\x16ListTopicSubscr\ + iptions\x12/.google.pubsub.v1.ListTopicSubscriptionsRequest\x1a0.google.\ + pubsub.v1.ListTopicSubscriptionsResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1\ + /{topic=projects/*/topics/*}/subscriptions\x12\xa2\x01\n\x12ListTopicSna\ + pshots\x12+.google.pubsub.v1.ListTopicSnapshotsRequest\x1a,.google.pubsu\ + b.v1.ListTopicSnapshotsResponse\"1\x82\xd3\xe4\x93\x02+\x12)/v1/{topic=p\ + rojects/*/topics/*}/snapshots\x12t\n\x0bDeleteTopic\x12$.google.pubsub.v\ + 1.DeleteTopicRequest\x1a\x16.google.protobuf.Empty\"'\x82\xd3\xe4\x93\ + \x02!*\x1f/v1/{topic=projects/*/topics/*}2\xf9\x11\n\nSubscriber\x12\x86\ + \x01\n\x12CreateSubscription\x12\x1e.google.pubsub.v1.Subscription\x1a\ + \x1e.google.pubsub.v1.Subscription\"0\x82\xd3\xe4\x93\x02*\x1a%/v1/{name\ + =projects/*/subscriptions/*}:\x01*\x12\x92\x01\n\x0fGetSubscription\x12(\ + .google.pubsub.v1.GetSubscriptionRequest\x1a\x1e.google.pubsub.v1.Subscr\ + iption\"5\x82\xd3\xe4\x93\x02/\x12-/v1/{subscription=projects/*/subscrip\ + tions/*}\x12\xa0\x01\n\x12UpdateSubscription\x12+.google.pubsub.v1.Updat\ + eSubscriptionRequest\x1a\x1e.google.pubsub.v1.Subscription\"=\x82\xd3\ + \xe4\x93\x02722/v1/{subscription.name=projects/*/subscriptions/*}:\x01*\ + \x12\x9c\x01\n\x11ListSubscriptions\x12*.google.pubsub.v1.ListSubscripti\ + onsRequest\x1a+.google.pubsub.v1.ListSubscriptionsResponse\".\x82\xd3\ + \xe4\x93\x02(\x12&/v1/{project=projects/*}/subscriptions\x12\x90\x01\n\ + \x12DeleteSubscription\x12+.google.pubsub.v1.DeleteSubscriptionRequest\ + \x1a\x16.google.protobuf.Empty\"5\x82\xd3\xe4\x93\x02/*-/v1/{subscriptio\ + n=projects/*/subscriptions/*}\x12\xa3\x01\n\x11ModifyAckDeadline\x12*.go\ + ogle.pubsub.v1.ModifyAckDeadlineRequest\x1a\x16.google.protobuf.Empty\"J\ + \x82\xd3\xe4\x93\x02D\"?/v1/{subscription=projects/*/subscriptions/*}:mo\ + difyAckDeadline:\x01*\x12\x91\x01\n\x0bAcknowledge\x12$.google.pubsub.v1\ + .AcknowledgeRequest\x1a\x16.google.protobuf.Empty\"D\x82\xd3\xe4\x93\x02\ + >\"9/v1/{subscription=projects/*/subscriptions/*}:acknowledge:\x01*\x12\ + \x84\x01\n\x04Pull\x12\x1d.google.pubsub.v1.PullRequest\x1a\x1e.google.p\ + ubsub.v1.PullResponse\"=\x82\xd3\xe4\x93\x027\"2/v1/{subscription=projec\ + ts/*/subscriptions/*}:pull:\x01*\x12f\n\rStreamingPull\x12&.google.pubsu\ + b.v1.StreamingPullRequest\x1a'.google.pubsub.v1.StreamingPullResponse\"\ + \0(\x010\x01\x12\xa0\x01\n\x10ModifyPushConfig\x12).google.pubsub.v1.Mod\ + ifyPushConfigRequest\x1a\x16.google.protobuf.Empty\"I\x82\xd3\xe4\x93\ + \x02C\">/v1/{subscription=projects/*/subscriptions/*}:modifyPushConfig:\ + \x01*\x12~\n\x0bGetSnapshot\x12$.google.pubsub.v1.GetSnapshotRequest\x1a\ + \x1a.google.pubsub.v1.Snapshot\"-\x82\xd3\xe4\x93\x02'\x12%/v1/{snapshot\ + =projects/*/snapshots/*}\x12\x8c\x01\n\rListSnapshots\x12&.google.pubsub\ + .v1.ListSnapshotsRequest\x1a'.google.pubsub.v1.ListSnapshotsResponse\"*\ + \x82\xd3\xe4\x93\x02$\x12\"/v1/{project=projects/*}/snapshots\x12\x83\ + \x01\n\x0eCreateSnapshot\x12'.google.pubsub.v1.CreateSnapshotRequest\x1a\ + \x1a.google.pubsub.v1.Snapshot\",\x82\xd3\xe4\x93\x02&\x1a!/v1/{name=pro\ + jects/*/snapshots/*}:\x01*\x12\x8c\x01\n\x0eUpdateSnapshot\x12'.google.p\ + ubsub.v1.UpdateSnapshotRequest\x1a\x1a.google.pubsub.v1.Snapshot\"5\x82\ + \xd3\xe4\x93\x02/2*/v1/{snapshot.name=projects/*/snapshots/*}:\x01*\x12\ + \x80\x01\n\x0eDeleteSnapshot\x12'.google.pubsub.v1.DeleteSnapshotRequest\ + \x1a\x16.google.protobuf.Empty\"-\x82\xd3\xe4\x93\x02'*%/v1/{snapshot=pr\ + ojects/*/snapshots/*}\x12\x84\x01\n\x04Seek\x12\x1d.google.pubsub.v1.See\ + kRequest\x1a\x1e.google.pubsub.v1.SeekResponse\"=\x82\xd3\xe4\x93\x027\"\ + 2/v1/{subscription=projects/*/subscriptions/*}:seek:\x01*B\x92\x01\n\x14\ + com.google.pubsub.v1B\x0bPubsubProtoP\x01Z6google.golang.org/genproto/go\ + ogleapis/pubsub/v1;pubsub\xf8\x01\x01\xaa\x02\x16Google.Cloud.PubSub.V1\ + \xca\x02\x16Google\\Cloud\\PubSub\\V1J\x9a\xba\x02\n\x07\x12\x05\x0f\0\ + \xab\x07\x01\n\xbe\x04\n\x01\x0c\x12\x03\x0f\0\x122\xb3\x04\x20Copyright\ + \x202018\x20Google\x20LLC.\n\n\x20Licensed\x20under\x20the\x20Apache\x20\ + License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20n\ + ot\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\ + \x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20Lice\ + nse\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-\ + 2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\ + \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\ + \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\ + \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\ + ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\ + the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\ + tations\x20under\x20the\x20License.\n\n\n\x08\n\x01\x02\x12\x03\x11\0\ + \x19\n\t\n\x02\x03\0\x12\x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\x14\0(\n\t\ + \n\x02\x03\x02\x12\x03\x15\0%\n\t\n\x02\x03\x03\x12\x03\x16\0*\n\t\n\x02\ + \x03\x04\x12\x03\x17\0)\n\x08\n\x01\x08\x12\x03\x19\0\x1f\n\t\n\x02\x08\ + \x1f\x12\x03\x19\0\x1f\n\x08\n\x01\x08\x12\x03\x1a\03\n\t\n\x02\x08%\x12\ + \x03\x1a\03\n\x08\n\x01\x08\x12\x03\x1b\0M\n\t\n\x02\x08\x0b\x12\x03\x1b\ + \0M\n\x08\n\x01\x08\x12\x03\x1c\0\"\n\t\n\x02\x08\n\x12\x03\x1c\0\"\n\ + \x08\n\x01\x08\x12\x03\x1d\0,\n\t\n\x02\x08\x08\x12\x03\x1d\0,\n\x08\n\ + \x01\x08\x12\x03\x1e\0-\n\t\n\x02\x08\x01\x12\x03\x1e\0-\n\x08\n\x01\x08\ + \x12\x03\x1f\03\n\t\n\x02\x08)\x12\x03\x1f\03\nj\n\x02\x06\0\x12\x04$\0i\ + \x01\x1a^\x20The\x20service\x20that\x20an\x20application\x20uses\x20to\ + \x20manipulate\x20topics,\x20and\x20to\x20send\n\x20messages\x20to\x20a\ + \x20topic.\n\n\n\n\x03\x06\0\x01\x12\x03$\x08\x11\n\x8b\x01\n\x04\x06\0\ + \x02\0\x12\x04'\x02,\x03\x1a}\x20Creates\x20the\x20given\x20topic\x20wit\ + h\x20the\x20given\x20name.\x20See\x20the\n\x20\x20resource\x20name\x20rules.\n\n\x0c\n\x05\ + \x06\0\x02\0\x01\x12\x03'\x06\x11\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03'\ + \x12\x17\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03'\"'\n\r\n\x05\x06\0\x02\0\ + \x04\x12\x04(\x04+\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04(\ + \x04+\x06\ng\n\x04\x06\0\x02\x01\x12\x040\x025\x03\x1aY\x20Updates\x20an\ + \x20existing\x20topic.\x20Note\x20that\x20certain\x20properties\x20of\ + \x20a\n\x20topic\x20are\x20not\x20modifiable.\n\n\x0c\n\x05\x06\0\x02\ + \x01\x01\x12\x030\x06\x11\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x030\x12$\n\ + \x0c\n\x05\x06\0\x02\x01\x03\x12\x030/4\n\r\n\x05\x06\0\x02\x01\x04\x12\ + \x041\x044\x06\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x041\x044\ + \x06\ni\n\x04\x06\0\x02\x02\x12\x049\x02>\x03\x1a[\x20Adds\x20one\x20or\ + \x20more\x20messages\x20to\x20the\x20topic.\x20Returns\x20`NOT_FOUND`\ + \x20if\x20the\x20topic\n\x20does\x20not\x20exist.\n\n\x0c\n\x05\x06\0\ + \x02\x02\x01\x12\x039\x06\r\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x039\x0e\ + \x1c\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x039'6\n\r\n\x05\x06\0\x02\x02\ + \x04\x12\x04:\x04=\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04\ + :\x04=\x06\n2\n\x04\x06\0\x02\x03\x12\x04A\x02E\x03\x1a$\x20Gets\x20the\ + \x20configuration\x20of\x20a\x20topic.\n\n\x0c\n\x05\x06\0\x02\x03\x01\ + \x12\x03A\x06\x0e\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03A\x0f\x1e\n\x0c\n\ + \x05\x06\0\x02\x03\x03\x12\x03A).\n\r\n\x05\x06\0\x02\x03\x04\x12\x04B\ + \x04D\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04B\x04D\x06\n&\ + \n\x04\x06\0\x02\x04\x12\x04H\x02L\x03\x1a\x18\x20Lists\x20matching\x20t\ + opics.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03H\x06\x10\n\x0c\n\x05\x06\ + \0\x02\x04\x02\x12\x03H\x11\"\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03H-?\n\ + \r\n\x05\x06\0\x02\x04\x04\x12\x04I\x04K\x06\n\x11\n\t\x06\0\x02\x04\x04\ + \xb0\xca\xbc\"\x12\x04I\x04K\x06\nC\n\x04\x06\0\x02\x05\x12\x04O\x02S\ + \x03\x1a5\x20Lists\x20the\x20names\x20of\x20the\x20subscriptions\x20on\ + \x20this\x20topic.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03O\x06\x1c\n\ + \x0c\n\x05\x06\0\x02\x05\x02\x12\x03O\x1d:\n\x0c\n\x05\x06\0\x02\x05\x03\ + \x12\x03OEc\n\r\n\x05\x06\0\x02\x05\x04\x12\x04P\x04R\x06\n\x11\n\t\x06\ + \0\x02\x05\x04\xb0\xca\xbc\"\x12\x04P\x04R\x06\n\x9a\x02\n\x04\x06\0\x02\ + \x06\x12\x04Y\x02]\x03\x1a\x8b\x02\x20Lists\x20the\x20names\x20of\x20the\ + \x20snapshots\x20on\x20this\x20topic.

\n\x20ALPHA:\x20This\ + \x20feature\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20AP\ + I\x20might\x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20\ + and\x20is\x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20\ + is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\ + \n\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03Y\x06\x18\n\x0c\n\x05\x06\0\x02\ + \x06\x02\x12\x03Y\x192\n\x0c\n\x05\x06\0\x02\x06\x03\x12\x03Y=W\n\r\n\ + \x05\x06\0\x02\x06\x04\x12\x04Z\x04\\\x06\n\x11\n\t\x06\0\x02\x06\x04\ + \xb0\xca\xbc\"\x12\x04Z\x04\\\x06\n\xf3\x02\n\x04\x06\0\x02\x07\x12\x04d\ + \x02h\x03\x1a\xe4\x02\x20Deletes\x20the\x20topic\x20with\x20the\x20given\ + \x20name.\x20Returns\x20`NOT_FOUND`\x20if\x20the\x20topic\n\x20does\x20n\ + ot\x20exist.\x20After\x20a\x20topic\x20is\x20deleted,\x20a\x20new\x20top\ + ic\x20may\x20be\x20created\x20with\n\x20the\x20same\x20name;\x20this\x20\ + is\x20an\x20entirely\x20new\x20topic\x20with\x20none\x20of\x20the\x20old\ + \n\x20configuration\x20or\x20subscriptions.\x20Existing\x20subscriptions\ + \x20to\x20this\x20topic\x20are\n\x20not\x20deleted,\x20but\x20their\x20`\ + topic`\x20field\x20is\x20set\x20to\x20`_deleted-topic_`.\n\n\x0c\n\x05\ + \x06\0\x02\x07\x01\x12\x03d\x06\x11\n\x0c\n\x05\x06\0\x02\x07\x02\x12\ + \x03d\x12$\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03d/D\n\r\n\x05\x06\0\x02\ + \x07\x04\x12\x04e\x04g\x06\n\x11\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\ + \x04e\x04g\x06\n\xe1\x01\n\x02\x06\x01\x12\x05n\0\xad\x02\x01\x1a\xd3\ + \x01\x20The\x20service\x20that\x20an\x20application\x20uses\x20to\x20man\ + ipulate\x20subscriptions\x20and\x20to\n\x20consume\x20messages\x20from\ + \x20a\x20subscription\x20via\x20the\x20`Pull`\x20method\x20or\x20by\n\ + \x20establishing\x20a\x20bi-directional\x20stream\x20using\x20the\x20`St\ + reamingPull`\x20method.\n\n\n\n\x03\x06\x01\x01\x12\x03n\x08\x12\n\x84\ + \x05\n\x04\x06\x01\x02\0\x12\x04z\x02\x7f\x03\x1a\xf5\x04\x20Creates\x20\ + a\x20subscription\x20to\x20a\x20given\x20topic.\x20See\x20the\n\x20\x20resource\x20name\x20r\ + ules.\n\x20If\x20the\x20subscription\x20already\x20exists,\x20return\ + s\x20`ALREADY_EXISTS`.\n\x20If\x20the\x20corresponding\x20topic\x20doesn\ + 't\x20exist,\x20returns\x20`NOT_FOUND`.\n\n\x20If\x20the\x20name\x20is\ + \x20not\x20provided\x20in\x20the\x20request,\x20the\x20server\x20will\ + \x20assign\x20a\x20random\n\x20name\x20for\x20this\x20subscription\x20on\ + \x20the\x20same\x20project\x20as\x20the\x20topic,\x20conforming\n\x20to\ + \x20the\n\x20[resource\x20name\x20format](https://cloud.google.com/pubsu\ + b/docs/overview#names).\n\x20The\x20generated\x20name\x20is\x20populated\ + \x20in\x20the\x20returned\x20Subscription\x20object.\n\x20Note\x20that\ + \x20for\x20REST\x20API\x20requests,\x20you\x20must\x20specify\x20a\x20na\ + me\x20in\x20the\x20request.\n\n\x0c\n\x05\x06\x01\x02\0\x01\x12\x03z\x06\ + \x18\n\x0c\n\x05\x06\x01\x02\0\x02\x12\x03z\x19%\n\x0c\n\x05\x06\x01\x02\ + \0\x03\x12\x03z0<\n\r\n\x05\x06\x01\x02\0\x04\x12\x04{\x04~\x06\n\x11\n\ + \t\x06\x01\x02\0\x04\xb0\xca\xbc\"\x12\x04{\x04~\x06\nC\n\x04\x06\x01\ + \x02\x01\x12\x06\x82\x01\x02\x86\x01\x03\x1a3\x20Gets\x20the\x20configur\ + ation\x20details\x20of\x20a\x20subscription.\n\n\r\n\x05\x06\x01\x02\x01\ + \x01\x12\x04\x82\x01\x06\x15\n\r\n\x05\x06\x01\x02\x01\x02\x12\x04\x82\ + \x01\x16,\n\r\n\x05\x06\x01\x02\x01\x03\x12\x04\x82\x017C\n\x0f\n\x05\ + \x06\x01\x02\x01\x04\x12\x06\x83\x01\x04\x85\x01\x06\n\x13\n\t\x06\x01\ + \x02\x01\x04\xb0\xca\xbc\"\x12\x06\x83\x01\x04\x85\x01\x06\n\x8b\x01\n\ + \x04\x06\x01\x02\x02\x12\x06\x8a\x01\x02\x8f\x01\x03\x1a{\x20Updates\x20\ + an\x20existing\x20subscription.\x20Note\x20that\x20certain\x20properties\ + \x20of\x20a\n\x20subscription,\x20such\x20as\x20its\x20topic,\x20are\x20\ + not\x20modifiable.\n\n\r\n\x05\x06\x01\x02\x02\x01\x12\x04\x8a\x01\x06\ + \x18\n\r\n\x05\x06\x01\x02\x02\x02\x12\x04\x8a\x01\x192\n\r\n\x05\x06\ + \x01\x02\x02\x03\x12\x04\x8a\x01=I\n\x0f\n\x05\x06\x01\x02\x02\x04\x12\ + \x06\x8b\x01\x04\x8e\x01\x06\n\x13\n\t\x06\x01\x02\x02\x04\xb0\xca\xbc\"\ + \x12\x06\x8b\x01\x04\x8e\x01\x06\n/\n\x04\x06\x01\x02\x03\x12\x06\x92\ + \x01\x02\x96\x01\x03\x1a\x1f\x20Lists\x20matching\x20subscriptions.\n\n\ + \r\n\x05\x06\x01\x02\x03\x01\x12\x04\x92\x01\x06\x17\n\r\n\x05\x06\x01\ + \x02\x03\x02\x12\x04\x92\x01\x180\n\r\n\x05\x06\x01\x02\x03\x03\x12\x04\ + \x92\x01;T\n\x0f\n\x05\x06\x01\x02\x03\x04\x12\x06\x93\x01\x04\x95\x01\ + \x06\n\x13\n\t\x06\x01\x02\x03\x04\xb0\xca\xbc\"\x12\x06\x93\x01\x04\x95\ + \x01\x06\n\xef\x02\n\x04\x06\x01\x02\x04\x12\x06\x9d\x01\x02\xa1\x01\x03\ + \x1a\xde\x02\x20Deletes\x20an\x20existing\x20subscription.\x20All\x20mes\ + sages\x20retained\x20in\x20the\x20subscription\n\x20are\x20immediately\ + \x20dropped.\x20Calls\x20to\x20`Pull`\x20after\x20deletion\x20will\x20re\ + turn\n\x20`NOT_FOUND`.\x20After\x20a\x20subscription\x20is\x20deleted,\ + \x20a\x20new\x20one\x20may\x20be\x20created\x20with\n\x20the\x20same\x20\ + name,\x20but\x20the\x20new\x20one\x20has\x20no\x20association\x20with\ + \x20the\x20old\n\x20subscription\x20or\x20its\x20topic\x20unless\x20the\ + \x20same\x20topic\x20is\x20specified.\n\n\r\n\x05\x06\x01\x02\x04\x01\ + \x12\x04\x9d\x01\x06\x18\n\r\n\x05\x06\x01\x02\x04\x02\x12\x04\x9d\x01\ + \x192\n\r\n\x05\x06\x01\x02\x04\x03\x12\x04\x9d\x01=R\n\x0f\n\x05\x06\ + \x01\x02\x04\x04\x12\x06\x9e\x01\x04\xa0\x01\x06\n\x13\n\t\x06\x01\x02\ + \x04\x04\xb0\xca\xbc\"\x12\x06\x9e\x01\x04\xa0\x01\x06\n\xe7\x02\n\x04\ + \x06\x01\x02\x05\x12\x06\xa8\x01\x02\xad\x01\x03\x1a\xd6\x02\x20Modifies\ + \x20the\x20ack\x20deadline\x20for\x20a\x20specific\x20message.\x20This\ + \x20method\x20is\x20useful\n\x20to\x20indicate\x20that\x20more\x20time\ + \x20is\x20needed\x20to\x20process\x20a\x20message\x20by\x20the\n\x20subs\ + criber,\x20or\x20to\x20make\x20the\x20message\x20available\x20for\x20red\ + elivery\x20if\x20the\n\x20processing\x20was\x20interrupted.\x20Note\x20t\ + hat\x20this\x20does\x20not\x20modify\x20the\n\x20subscription-level\x20`\ + ackDeadlineSeconds`\x20used\x20for\x20subsequent\x20messages.\n\n\r\n\ + \x05\x06\x01\x02\x05\x01\x12\x04\xa8\x01\x06\x17\n\r\n\x05\x06\x01\x02\ + \x05\x02\x12\x04\xa8\x01\x180\n\r\n\x05\x06\x01\x02\x05\x03\x12\x04\xa8\ + \x01;P\n\x0f\n\x05\x06\x01\x02\x05\x04\x12\x06\xa9\x01\x04\xac\x01\x06\n\ + \x13\n\t\x06\x01\x02\x05\x04\xb0\xca\xbc\"\x12\x06\xa9\x01\x04\xac\x01\ + \x06\n\xed\x02\n\x04\x06\x01\x02\x06\x12\x06\xb6\x01\x02\xbb\x01\x03\x1a\ + \xdc\x02\x20Acknowledges\x20the\x20messages\x20associated\x20with\x20the\ + \x20`ack_ids`\x20in\x20the\n\x20`AcknowledgeRequest`.\x20The\x20Pub/Sub\ + \x20system\x20can\x20remove\x20the\x20relevant\x20messages\n\x20from\x20\ + the\x20subscription.\n\n\x20Acknowledging\x20a\x20message\x20whose\x20ac\ + k\x20deadline\x20has\x20expired\x20may\x20succeed,\n\x20but\x20such\x20a\ + \x20message\x20may\x20be\x20redelivered\x20later.\x20Acknowledging\x20a\ + \x20message\x20more\n\x20than\x20once\x20will\x20not\x20result\x20in\x20\ + an\x20error.\n\n\r\n\x05\x06\x01\x02\x06\x01\x12\x04\xb6\x01\x06\x11\n\r\ + \n\x05\x06\x01\x02\x06\x02\x12\x04\xb6\x01\x12$\n\r\n\x05\x06\x01\x02\ + \x06\x03\x12\x04\xb6\x01/D\n\x0f\n\x05\x06\x01\x02\x06\x04\x12\x06\xb7\ + \x01\x04\xba\x01\x06\n\x13\n\t\x06\x01\x02\x06\x04\xb0\xca\xbc\"\x12\x06\ + \xb7\x01\x04\xba\x01\x06\n\xab\x01\n\x04\x06\x01\x02\x07\x12\x06\xc0\x01\ + \x02\xc5\x01\x03\x1a\x9a\x01\x20Pulls\x20messages\x20from\x20the\x20serv\ + er.\x20The\x20server\x20may\x20return\x20`UNAVAILABLE`\x20if\n\x20there\ + \x20are\x20too\x20many\x20concurrent\x20pull\x20requests\x20pending\x20f\ + or\x20the\x20given\n\x20subscription.\n\n\r\n\x05\x06\x01\x02\x07\x01\ + \x12\x04\xc0\x01\x06\n\n\r\n\x05\x06\x01\x02\x07\x02\x12\x04\xc0\x01\x0b\ + \x16\n\r\n\x05\x06\x01\x02\x07\x03\x12\x04\xc0\x01!-\n\x0f\n\x05\x06\x01\ + \x02\x07\x04\x12\x06\xc1\x01\x04\xc4\x01\x06\n\x13\n\t\x06\x01\x02\x07\ + \x04\xb0\xca\xbc\"\x12\x06\xc1\x01\x04\xc4\x01\x06\n\xe2\x03\n\x04\x06\ + \x01\x02\x08\x12\x06\xce\x01\x02\xcf\x01\x03\x1a\xd1\x03\x20Establishes\ + \x20a\x20stream\x20with\x20the\x20server,\x20which\x20sends\x20messages\ + \x20down\x20to\x20the\n\x20client.\x20The\x20client\x20streams\x20acknow\ + ledgements\x20and\x20ack\x20deadline\x20modifications\n\x20back\x20to\ + \x20the\x20server.\x20The\x20server\x20will\x20close\x20the\x20stream\ + \x20and\x20return\x20the\x20status\n\x20on\x20any\x20error.\x20The\x20se\ + rver\x20may\x20close\x20the\x20stream\x20with\x20status\x20`UNAVAILABLE`\ + \x20to\n\x20reassign\x20server-side\x20resources,\x20in\x20which\x20case\ + ,\x20the\x20client\x20should\n\x20re-establish\x20the\x20stream.\x20Flow\ + \x20control\x20can\x20be\x20achieved\x20by\x20configuring\x20the\n\x20un\ + derlying\x20RPC\x20channel.\n\n\r\n\x05\x06\x01\x02\x08\x01\x12\x04\xce\ + \x01\x06\x13\n\r\n\x05\x06\x01\x02\x08\x05\x12\x04\xce\x01\x14\x1a\n\r\n\ + \x05\x06\x01\x02\x08\x02\x12\x04\xce\x01\x1b/\n\r\n\x05\x06\x01\x02\x08\ + \x06\x12\x04\xce\x01:@\n\r\n\x05\x06\x01\x02\x08\x03\x12\x04\xce\x01AV\n\ + \xf7\x02\n\x04\x06\x01\x02\t\x12\x06\xd7\x01\x02\xdc\x01\x03\x1a\xe6\x02\ + \x20Modifies\x20the\x20`PushConfig`\x20for\x20a\x20specified\x20subscrip\ + tion.\n\n\x20This\x20may\x20be\x20used\x20to\x20change\x20a\x20push\x20s\ + ubscription\x20to\x20a\x20pull\x20one\x20(signified\x20by\n\x20an\x20emp\ + ty\x20`PushConfig`)\x20or\x20vice\x20versa,\x20or\x20change\x20the\x20en\ + dpoint\x20URL\x20and\x20other\n\x20attributes\x20of\x20a\x20push\x20subs\ + cription.\x20Messages\x20will\x20accumulate\x20for\x20delivery\n\x20cont\ + inuously\x20through\x20the\x20call\x20regardless\x20of\x20changes\x20to\ + \x20the\x20`PushConfig`.\n\n\r\n\x05\x06\x01\x02\t\x01\x12\x04\xd7\x01\ + \x06\x16\n\r\n\x05\x06\x01\x02\t\x02\x12\x04\xd7\x01\x17.\n\r\n\x05\x06\ + \x01\x02\t\x03\x12\x04\xd7\x019N\n\x0f\n\x05\x06\x01\x02\t\x04\x12\x06\ + \xd8\x01\x04\xdb\x01\x06\n\x13\n\t\x06\x01\x02\t\x04\xb0\xca\xbc\"\x12\ + \x06\xd8\x01\x04\xdb\x01\x06\n\x9a\x02\n\x04\x06\x01\x02\n\x12\x06\xe2\ + \x01\x02\xe6\x01\x03\x1a\x89\x02\x20Gets\x20the\x20configuration\x20deta\ + ils\x20of\x20a\x20snapshot.

\n\x20ALPHA:\x20This\x20featur\ + e\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\ + \x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\ + \x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20is\x20not\ + \x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\r\n\ + \x05\x06\x01\x02\n\x01\x12\x04\xe2\x01\x06\x11\n\r\n\x05\x06\x01\x02\n\ + \x02\x12\x04\xe2\x01\x12$\n\r\n\x05\x06\x01\x02\n\x03\x12\x04\xe2\x01/7\ + \n\x0f\n\x05\x06\x01\x02\n\x04\x12\x06\xe3\x01\x04\xe5\x01\x06\n\x13\n\t\ + \x06\x01\x02\n\x04\xb0\xca\xbc\"\x12\x06\xe3\x01\x04\xe5\x01\x06\n\x8a\ + \x02\n\x04\x06\x01\x02\x0b\x12\x06\xec\x01\x02\xf0\x01\x03\x1a\xf9\x01\ + \x20Lists\x20the\x20existing\x20snapshots.

\n\x20ALPHA:\ + \x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20Th\ + is\x20API\x20might\x20be\n\x20changed\x20in\x20backward-incompatible\x20\ + ways\x20and\x20is\x20not\x20recommended\x20for\x20production\n\x20use.\ + \x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\ + \x20policy.\n\n\r\n\x05\x06\x01\x02\x0b\x01\x12\x04\xec\x01\x06\x13\n\r\ + \n\x05\x06\x01\x02\x0b\x02\x12\x04\xec\x01\x14(\n\r\n\x05\x06\x01\x02\ + \x0b\x03\x12\x04\xec\x013H\n\x0f\n\x05\x06\x01\x02\x0b\x04\x12\x06\xed\ + \x01\x04\xef\x01\x06\n\x13\n\t\x06\x01\x02\x0b\x04\xb0\xca\xbc\"\x12\x06\ + \xed\x01\x04\xef\x01\x06\n\xe7\x07\n\x04\x06\x01\x02\x0c\x12\x06\x81\x02\ + \x02\x86\x02\x03\x1a\xd6\x07\x20Creates\x20a\x20snapshot\x20from\x20the\ + \x20requested\x20subscription.

\n\x20ALPHA:\x20This\x20fea\ + ture\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20mi\ + ght\x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20\ + is\x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20is\x20n\ + ot\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.
\n\x20If\x20the\x20snapshot\x20already\x20exists,\x20returns\x20`ALREAD\ + Y_EXISTS`.\n\x20If\x20the\x20requested\x20subscription\x20doesn't\x20exi\ + st,\x20returns\x20`NOT_FOUND`.\n\x20If\x20the\x20backlog\x20in\x20the\ + \x20subscription\x20is\x20too\x20old\x20--\x20and\x20the\x20resulting\ + \x20snapshot\n\x20would\x20expire\x20in\x20less\x20than\x201\x20hour\x20\ + --\x20then\x20`FAILED_PRECONDITION`\x20is\x20returned.\n\x20See\x20also\ + \x20the\x20`Snapshot.expire_time`\x20field.\x20If\x20the\x20name\x20is\ + \x20not\x20provided\x20in\n\x20the\x20request,\x20the\x20server\x20will\ + \x20assign\x20a\x20random\n\x20name\x20for\x20this\x20snapshot\x20on\x20\ + the\x20same\x20project\x20as\x20the\x20subscription,\x20conforming\n\x20\ + to\x20the\x20[resource\x20name\x20format](https://cloud.google.com/pubsu\ + b/docs/overview#names).\n\x20The\x20generated\n\x20name\x20is\x20populat\ + ed\x20in\x20the\x20returned\x20Snapshot\x20object.\x20Note\x20that\x20fo\ + r\x20REST\x20API\n\x20requests,\x20you\x20must\x20specify\x20a\x20name\ + \x20in\x20the\x20request.\n\n\r\n\x05\x06\x01\x02\x0c\x01\x12\x04\x81\ + \x02\x06\x14\n\r\n\x05\x06\x01\x02\x0c\x02\x12\x04\x81\x02\x15*\n\r\n\ + \x05\x06\x01\x02\x0c\x03\x12\x04\x81\x025=\n\x0f\n\x05\x06\x01\x02\x0c\ + \x04\x12\x06\x82\x02\x04\x85\x02\x06\n\x13\n\t\x06\x01\x02\x0c\x04\xb0\ + \xca\xbc\"\x12\x06\x82\x02\x04\x85\x02\x06\n\xca\x02\n\x04\x06\x01\x02\r\ + \x12\x06\x8d\x02\x02\x92\x02\x03\x1a\xb9\x02\x20Updates\x20an\x20existin\ + g\x20snapshot.

\n\x20ALPHA:\x20This\x20feature\x20is\x20pa\ + rt\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\x20be\n\x20c\ + hanged\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\x20rec\ + ommended\x20for\x20production\n\x20use.\x20It\x20is\x20not\x20subject\ + \x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\x20Note\x20that\ + \x20certain\x20properties\x20of\x20a\x20snapshot\x20are\x20not\x20modifi\ + able.\n\n\r\n\x05\x06\x01\x02\r\x01\x12\x04\x8d\x02\x06\x14\n\r\n\x05\ + \x06\x01\x02\r\x02\x12\x04\x8d\x02\x15*\n\r\n\x05\x06\x01\x02\r\x03\x12\ + \x04\x8d\x025=\n\x0f\n\x05\x06\x01\x02\r\x04\x12\x06\x8e\x02\x04\x91\x02\ + \x06\n\x13\n\t\x06\x01\x02\r\x04\xb0\xca\xbc\"\x12\x06\x8e\x02\x04\x91\ + \x02\x06\n\xaf\x04\n\x04\x06\x01\x02\x0e\x12\x06\x9c\x02\x02\xa0\x02\x03\ + \x1a\x9e\x04\x20Removes\x20an\x20existing\x20snapshot.\x20

\n\x20\ + ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\x20r\ + elease.\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backward-inc\ + ompatible\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20productio\ + n\n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20d\ + eprecation\x20policy.\n\x20When\x20the\x20snapshot\x20is\x20deleted,\x20\ + all\x20messages\x20retained\x20in\x20the\x20snapshot\n\x20are\x20immedia\ + tely\x20dropped.\x20After\x20a\x20snapshot\x20is\x20deleted,\x20a\x20new\ + \x20one\x20may\x20be\n\x20created\x20with\x20the\x20same\x20name,\x20but\ + \x20the\x20new\x20one\x20has\x20no\x20association\x20with\x20the\x20old\ + \n\x20snapshot\x20or\x20its\x20subscription,\x20unless\x20the\x20same\ + \x20subscription\x20is\x20specified.\n\n\r\n\x05\x06\x01\x02\x0e\x01\x12\ + \x04\x9c\x02\x06\x14\n\r\n\x05\x06\x01\x02\x0e\x02\x12\x04\x9c\x02\x15*\ + \n\r\n\x05\x06\x01\x02\x0e\x03\x12\x04\x9c\x025J\n\x0f\n\x05\x06\x01\x02\ + \x0e\x04\x12\x06\x9d\x02\x04\x9f\x02\x06\n\x13\n\t\x06\x01\x02\x0e\x04\ + \xb0\xca\xbc\"\x12\x06\x9d\x02\x04\x9f\x02\x06\n\xdd\x02\n\x04\x06\x01\ + \x02\x0f\x12\x06\xa7\x02\x02\xac\x02\x03\x1a\xcc\x02\x20Seeks\x20an\x20e\ + xisting\x20subscription\x20to\x20a\x20point\x20in\x20time\x20or\x20to\ + \x20a\x20given\x20snapshot,\n\x20whichever\x20is\x20provided\x20in\x20th\ + e\x20request.

\n\x20ALPHA:\x20This\x20feature\x20is\x20par\ + t\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\x20be\n\x20ch\ + anged\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\x20reco\ + mmended\x20for\x20production\n\x20use.\x20It\x20is\x20not\x20subject\x20\ + to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\r\n\x05\x06\x01\x02\ + \x0f\x01\x12\x04\xa7\x02\x06\n\n\r\n\x05\x06\x01\x02\x0f\x02\x12\x04\xa7\ + \x02\x0b\x16\n\r\n\x05\x06\x01\x02\x0f\x03\x12\x04\xa7\x02!-\n\x0f\n\x05\ + \x06\x01\x02\x0f\x04\x12\x06\xa8\x02\x04\xab\x02\x06\n\x13\n\t\x06\x01\ + \x02\x0f\x04\xb0\xca\xbc\"\x12\x06\xa8\x02\x04\xab\x02\x06\n\x0c\n\x02\ + \x04\0\x12\x06\xaf\x02\0\xb7\x02\x01\n\x0b\n\x03\x04\0\x01\x12\x04\xaf\ + \x02\x08\x1c\n\xa4\x03\n\x04\x04\0\x02\0\x12\x04\xb6\x02\x022\x1a\x95\ + \x03\x20The\x20list\x20of\x20GCP\x20regions\x20where\x20messages\x20that\ + \x20are\x20published\x20to\x20the\x20topic\x20may\n\x20be\x20persisted\ + \x20in\x20storage.\x20Messages\x20published\x20by\x20publishers\x20runni\ + ng\x20in\n\x20non-allowed\x20GCP\x20regions\x20(or\x20running\x20outside\ + \x20of\x20GCP\x20altogether)\x20will\x20be\n\x20routed\x20for\x20storage\ + \x20in\x20one\x20of\x20the\x20allowed\x20regions.\x20An\x20empty\x20list\ + \x20indicates\x20a\n\x20misconfiguration\x20at\x20the\x20project\x20or\ + \x20organization\x20level,\x20which\x20will\x20result\x20in\n\x20all\x20\ + Publish\x20operations\x20failing.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04\ + \xb6\x02\x02\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xb6\x02\x0b\x11\n\r\n\ + \x05\x04\0\x02\0\x01\x12\x04\xb6\x02\x12-\n\r\n\x05\x04\0\x02\0\x03\x12\ + \x04\xb6\x0201\n!\n\x02\x04\x01\x12\x06\xba\x02\0\xcd\x02\x01\x1a\x13\ + \x20A\x20topic\x20resource.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xba\x02\ + \x08\r\n\x82\x03\n\x04\x04\x01\x02\0\x12\x04\xc1\x02\x02\x12\x1a\xf3\x02\ + \x20The\x20name\x20of\x20the\x20topic.\x20It\x20must\x20have\x20the\x20f\ + ormat\n\x20`\"projects/{project}/topics/{topic}\"`.\x20`{topic}`\x20must\ + \x20start\x20with\x20a\x20letter,\n\x20and\x20contain\x20only\x20letters\ + \x20(`[A-Za-z]`),\x20numbers\x20(`[0-9]`),\x20dashes\x20(`-`),\n\x20unde\ + rscores\x20(`_`),\x20periods\x20(`.`),\x20tildes\x20(`~`),\x20plus\x20(`\ + +`)\x20or\x20percent\n\x20signs\x20(`%`).\x20It\x20must\x20be\x20between\ + \x203\x20and\x20255\x20characters\x20in\x20length,\x20and\x20it\n\x20mus\ + t\x20not\x20start\x20with\x20`\"goog\"`.\n\n\x0f\n\x05\x04\x01\x02\0\x04\ + \x12\x06\xc1\x02\x02\xba\x02\x0f\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\xc1\ + \x02\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xc1\x02\t\r\n\r\n\x05\ + \x04\x01\x02\0\x03\x12\x04\xc1\x02\x10\x11\nT\n\x04\x04\x01\x02\x01\x12\ + \x04\xc4\x02\x02!\x1aF\x20See\x20\x20\ + Creating\x20and\x20managing\x20labels.\n\n\x0f\n\x05\x04\x01\x02\x01\ + \x04\x12\x06\xc4\x02\x02\xc1\x02\x12\n\r\n\x05\x04\x01\x02\x01\x06\x12\ + \x04\xc4\x02\x02\x15\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\xc4\x02\x16\ + \x1c\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xc4\x02\x1f\x20\n\xab\x03\n\ + \x04\x04\x01\x02\x02\x12\x04\xcc\x02\x022\x1a\x9c\x03\x20Policy\x20const\ + raining\x20how\x20messages\x20published\x20to\x20the\x20topic\x20may\x20\ + be\x20stored.\x20It\n\x20is\x20determined\x20when\x20the\x20topic\x20is\ + \x20created\x20based\x20on\x20the\x20policy\x20configured\x20at\n\x20the\ + \x20project\x20level.\x20It\x20must\x20not\x20be\x20set\x20by\x20the\x20\ + caller\x20in\x20the\x20request\x20to\n\x20CreateTopic\x20or\x20to\x20Upd\ + ateTopic.\x20This\x20field\x20will\x20be\x20populated\x20in\x20the\n\x20\ + responses\x20for\x20GetTopic,\x20CreateTopic,\x20and\x20UpdateTopic:\x20\ + if\x20not\x20present\x20in\x20the\n\x20response,\x20then\x20no\x20constr\ + aints\x20are\x20in\x20effect.\n\n\x0f\n\x05\x04\x01\x02\x02\x04\x12\x06\ + \xcc\x02\x02\xc4\x02!\n\r\n\x05\x04\x01\x02\x02\x06\x12\x04\xcc\x02\x02\ + \x16\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xcc\x02\x17-\n\r\n\x05\x04\ + \x01\x02\x02\x03\x12\x04\xcc\x0201\n\x8a\x02\n\x02\x04\x02\x12\x06\xd3\ + \x02\0\xe5\x02\x01\x1a\xfb\x01\x20A\x20message\x20that\x20is\x20publishe\ + d\x20by\x20publishers\x20and\x20consumed\x20by\x20subscribers.\x20The\n\ + \x20message\x20must\x20contain\x20either\x20a\x20non-empty\x20data\x20fi\ + eld\x20or\x20at\x20least\x20one\x20attribute.\n\x20See\x20Quotas\x20and\x20limits\x20for\x20more\x20informatio\ + n\x20about\n\x20message\x20limits.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xd3\ + \x02\x08\x15\nq\n\x04\x04\x02\x02\0\x12\x04\xd6\x02\x02\x11\x1ac\x20The\ + \x20message\x20data\x20field.\x20If\x20this\x20field\x20is\x20empty,\x20\ + the\x20message\x20must\x20contain\n\x20at\x20least\x20one\x20attribute.\ + \n\n\x0f\n\x05\x04\x02\x02\0\x04\x12\x06\xd6\x02\x02\xd3\x02\x17\n\r\n\ + \x05\x04\x02\x02\0\x05\x12\x04\xd6\x02\x02\x07\n\r\n\x05\x04\x02\x02\0\ + \x01\x12\x04\xd6\x02\x08\x0c\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\xd6\x02\ + \x0f\x10\n5\n\x04\x04\x02\x02\x01\x12\x04\xd9\x02\x02%\x1a'\x20Optional\ + \x20attributes\x20for\x20this\x20message.\n\n\x0f\n\x05\x04\x02\x02\x01\ + \x04\x12\x06\xd9\x02\x02\xd6\x02\x11\n\r\n\x05\x04\x02\x02\x01\x06\x12\ + \x04\xd9\x02\x02\x15\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xd9\x02\x16\ + \x20\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xd9\x02#$\n\xb3\x02\n\x04\x04\ + \x02\x02\x02\x12\x04\xdf\x02\x02\x18\x1a\xa4\x02\x20ID\x20of\x20this\x20\ + message,\x20assigned\x20by\x20the\x20server\x20when\x20the\x20message\ + \x20is\x20published.\n\x20Guaranteed\x20to\x20be\x20unique\x20within\x20\ + the\x20topic.\x20This\x20value\x20may\x20be\x20read\x20by\x20a\n\x20subs\ + criber\x20that\x20receives\x20a\x20`PubsubMessage`\x20via\x20a\x20`Pull`\ + \x20call\x20or\x20a\x20push\n\x20delivery.\x20It\x20must\x20not\x20be\ + \x20populated\x20by\x20the\x20publisher\x20in\x20a\x20`Publish`\x20call.\ + \n\n\x0f\n\x05\x04\x02\x02\x02\x04\x12\x06\xdf\x02\x02\xd9\x02%\n\r\n\ + \x05\x04\x02\x02\x02\x05\x12\x04\xdf\x02\x02\x08\n\r\n\x05\x04\x02\x02\ + \x02\x01\x12\x04\xdf\x02\t\x13\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\xdf\ + \x02\x16\x17\n\xbb\x01\n\x04\x04\x02\x02\x03\x12\x04\xe4\x02\x02-\x1a\ + \xac\x01\x20The\x20time\x20at\x20which\x20the\x20message\x20was\x20publi\ + shed,\x20populated\x20by\x20the\x20server\x20when\n\x20it\x20receives\ + \x20the\x20`Publish`\x20call.\x20It\x20must\x20not\x20be\x20populated\ + \x20by\x20the\n\x20publisher\x20in\x20a\x20`Publish`\x20call.\n\n\x0f\n\ + \x05\x04\x02\x02\x03\x04\x12\x06\xe4\x02\x02\xdf\x02\x18\n\r\n\x05\x04\ + \x02\x02\x03\x06\x12\x04\xe4\x02\x02\x1b\n\r\n\x05\x04\x02\x02\x03\x01\ + \x12\x04\xe4\x02\x1c(\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\xe4\x02+,\n0\ + \n\x02\x04\x03\x12\x06\xe8\x02\0\xec\x02\x01\x1a\"\x20Request\x20for\x20\ + the\x20GetTopic\x20method.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xe8\x02\x08\ + \x17\n]\n\x04\x04\x03\x02\0\x12\x04\xeb\x02\x02\x13\x1aO\x20The\x20name\ + \x20of\x20the\x20topic\x20to\x20get.\n\x20Format\x20is\x20`projects/{pro\ + ject}/topics/{topic}`.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xeb\x02\ + \x02\xe8\x02\x19\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\xeb\x02\x02\x08\n\r\ + \n\x05\x04\x03\x02\0\x01\x12\x04\xeb\x02\t\x0e\n\r\n\x05\x04\x03\x02\0\ + \x03\x12\x04\xeb\x02\x11\x12\n3\n\x02\x04\x04\x12\x06\xef\x02\0\xf9\x02\ + \x01\x1a%\x20Request\x20for\x20the\x20UpdateTopic\x20method.\n\n\x0b\n\ + \x03\x04\x04\x01\x12\x04\xef\x02\x08\x1a\n)\n\x04\x04\x04\x02\0\x12\x04\ + \xf1\x02\x02\x12\x1a\x1b\x20The\x20updated\x20topic\x20object.\n\n\x0f\n\ + \x05\x04\x04\x02\0\x04\x12\x06\xf1\x02\x02\xef\x02\x1c\n\r\n\x05\x04\x04\ + \x02\0\x06\x12\x04\xf1\x02\x02\x07\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\ + \xf1\x02\x08\r\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xf1\x02\x10\x11\n\xe1\ + \x02\n\x04\x04\x04\x02\x01\x12\x04\xf8\x02\x02,\x1a\xd2\x02\x20Indicates\ + \x20which\x20fields\x20in\x20the\x20provided\x20topic\x20to\x20update.\ + \x20Must\x20be\x20specified\n\x20and\x20non-empty.\x20Note\x20that\x20if\ + \x20`update_mask`\x20contains\n\x20\"message_storage_policy\"\x20then\ + \x20the\x20new\x20value\x20will\x20be\x20determined\x20based\x20on\x20th\ + e\n\x20policy\x20configured\x20at\x20the\x20project\x20or\x20organizatio\ + n\x20level.\x20The\n\x20`message_storage_policy`\x20must\x20not\x20be\ + \x20set\x20in\x20the\x20`topic`\x20provided\x20above.\n\n\x0f\n\x05\x04\ + \x04\x02\x01\x04\x12\x06\xf8\x02\x02\xf1\x02\x12\n\r\n\x05\x04\x04\x02\ + \x01\x06\x12\x04\xf8\x02\x02\x1b\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\ + \xf8\x02\x1c'\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xf8\x02*+\n/\n\x02\ + \x04\x05\x12\x06\xfc\x02\0\x83\x03\x01\x1a!\x20Request\x20for\x20the\x20\ + Publish\x20method.\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xfc\x02\x08\x16\n|\ + \n\x04\x04\x05\x02\0\x12\x04\xff\x02\x02\x13\x1an\x20The\x20messages\x20\ + in\x20the\x20request\x20will\x20be\x20published\x20on\x20this\x20topic.\ + \n\x20Format\x20is\x20`projects/{project}/topics/{topic}`.\n\n\x0f\n\x05\ + \x04\x05\x02\0\x04\x12\x06\xff\x02\x02\xfc\x02\x18\n\r\n\x05\x04\x05\x02\ + \0\x05\x12\x04\xff\x02\x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\xff\ + \x02\t\x0e\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\xff\x02\x11\x12\n(\n\x04\ + \x04\x05\x02\x01\x12\x04\x82\x03\x02&\x1a\x1a\x20The\x20messages\x20to\ + \x20publish.\n\n\r\n\x05\x04\x05\x02\x01\x04\x12\x04\x82\x03\x02\n\n\r\n\ + \x05\x04\x05\x02\x01\x06\x12\x04\x82\x03\x0b\x18\n\r\n\x05\x04\x05\x02\ + \x01\x01\x12\x04\x82\x03\x19!\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\x82\ + \x03$%\n2\n\x02\x04\x06\x12\x06\x86\x03\0\x8b\x03\x01\x1a$\x20Response\ + \x20for\x20the\x20`Publish`\x20method.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\ + \x86\x03\x08\x17\n\xa8\x01\n\x04\x04\x06\x02\0\x12\x04\x8a\x03\x02\"\x1a\ + \x99\x01\x20The\x20server-assigned\x20ID\x20of\x20each\x20published\x20m\ + essage,\x20in\x20the\x20same\x20order\x20as\n\x20the\x20messages\x20in\ + \x20the\x20request.\x20IDs\x20are\x20guaranteed\x20to\x20be\x20unique\ + \x20within\n\x20the\x20topic.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04\x8a\ + \x03\x02\n\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\x8a\x03\x0b\x11\n\r\n\x05\ + \x04\x06\x02\0\x01\x12\x04\x8a\x03\x12\x1d\n\r\n\x05\x04\x06\x02\0\x03\ + \x12\x04\x8a\x03\x20!\n4\n\x02\x04\x07\x12\x06\x8e\x03\0\x9a\x03\x01\x1a\ + &\x20Request\x20for\x20the\x20`ListTopics`\x20method.\n\n\x0b\n\x03\x04\ + \x07\x01\x12\x04\x8e\x03\x08\x19\nd\n\x04\x04\x07\x02\0\x12\x04\x91\x03\ + \x02\x15\x1aV\x20The\x20name\x20of\x20the\x20project\x20in\x20which\x20t\ + o\x20list\x20topics.\n\x20Format\x20is\x20`projects/{project-id}`.\n\n\ + \x0f\n\x05\x04\x07\x02\0\x04\x12\x06\x91\x03\x02\x8e\x03\x1b\n\r\n\x05\ + \x04\x07\x02\0\x05\x12\x04\x91\x03\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\ + \x12\x04\x91\x03\t\x10\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\x91\x03\x13\ + \x14\n3\n\x04\x04\x07\x02\x01\x12\x04\x94\x03\x02\x16\x1a%\x20Maximum\ + \x20number\x20of\x20topics\x20to\x20return.\n\n\x0f\n\x05\x04\x07\x02\ + \x01\x04\x12\x06\x94\x03\x02\x91\x03\x15\n\r\n\x05\x04\x07\x02\x01\x05\ + \x12\x04\x94\x03\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x94\x03\ + \x08\x11\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\x94\x03\x14\x15\n\xc4\x01\ + \n\x04\x04\x07\x02\x02\x12\x04\x99\x03\x02\x18\x1a\xb5\x01\x20The\x20val\ + ue\x20returned\x20by\x20the\x20last\x20`ListTopicsResponse`;\x20indicate\ + s\x20that\x20this\x20is\n\x20a\x20continuation\x20of\x20a\x20prior\x20`L\ + istTopics`\x20call,\x20and\x20that\x20the\x20system\x20should\n\x20retur\ + n\x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\x05\x04\x07\x02\x02\ + \x04\x12\x06\x99\x03\x02\x94\x03\x16\n\r\n\x05\x04\x07\x02\x02\x05\x12\ + \x04\x99\x03\x02\x08\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\x99\x03\t\x13\ + \n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\x99\x03\x16\x17\n5\n\x02\x04\x08\ + \x12\x06\x9d\x03\0\xa4\x03\x01\x1a'\x20Response\x20for\x20the\x20`ListTo\ + pics`\x20method.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\x9d\x03\x08\x1a\n%\n\ + \x04\x04\x08\x02\0\x12\x04\x9f\x03\x02\x1c\x1a\x17\x20The\x20resulting\ + \x20topics.\n\n\r\n\x05\x04\x08\x02\0\x04\x12\x04\x9f\x03\x02\n\n\r\n\ + \x05\x04\x08\x02\0\x06\x12\x04\x9f\x03\x0b\x10\n\r\n\x05\x04\x08\x02\0\ + \x01\x12\x04\x9f\x03\x11\x17\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x9f\x03\ + \x1a\x1b\n\x99\x01\n\x04\x04\x08\x02\x01\x12\x04\xa3\x03\x02\x1d\x1a\x8a\ + \x01\x20If\x20not\x20empty,\x20indicates\x20that\x20there\x20may\x20be\ + \x20more\x20topics\x20that\x20match\x20the\n\x20request;\x20this\x20valu\ + e\x20should\x20be\x20passed\x20in\x20a\x20new\x20`ListTopicsRequest`.\n\ + \n\x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\xa3\x03\x02\x9f\x03\x1c\n\r\n\ + \x05\x04\x08\x02\x01\x05\x12\x04\xa3\x03\x02\x08\n\r\n\x05\x04\x08\x02\ + \x01\x01\x12\x04\xa3\x03\t\x18\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xa3\ + \x03\x1b\x1c\n@\n\x02\x04\t\x12\x06\xa7\x03\0\xb3\x03\x01\x1a2\x20Reques\ + t\x20for\x20the\x20`ListTopicSubscriptions`\x20method.\n\n\x0b\n\x03\x04\ + \t\x01\x12\x04\xa7\x03\x08%\ny\n\x04\x04\t\x02\0\x12\x04\xaa\x03\x02\x13\ + \x1ak\x20The\x20name\x20of\x20the\x20topic\x20that\x20subscriptions\x20a\ + re\x20attached\x20to.\n\x20Format\x20is\x20`projects/{project}/topics/{t\ + opic}`.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\x06\xaa\x03\x02\xa7\x03'\n\r\n\ + \x05\x04\t\x02\0\x05\x12\x04\xaa\x03\x02\x08\n\r\n\x05\x04\t\x02\0\x01\ + \x12\x04\xaa\x03\t\x0e\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xaa\x03\x11\x12\ + \n?\n\x04\x04\t\x02\x01\x12\x04\xad\x03\x02\x16\x1a1\x20Maximum\x20numbe\ + r\x20of\x20subscription\x20names\x20to\x20return.\n\n\x0f\n\x05\x04\t\ + \x02\x01\x04\x12\x06\xad\x03\x02\xaa\x03\x13\n\r\n\x05\x04\t\x02\x01\x05\ + \x12\x04\xad\x03\x02\x07\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\xad\x03\x08\ + \x11\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xad\x03\x14\x15\n\xdc\x01\n\x04\ + \x04\t\x02\x02\x12\x04\xb2\x03\x02\x18\x1a\xcd\x01\x20The\x20value\x20re\ + turned\x20by\x20the\x20last\x20`ListTopicSubscriptionsResponse`;\x20indi\ + cates\n\x20that\x20this\x20is\x20a\x20continuation\x20of\x20a\x20prior\ + \x20`ListTopicSubscriptions`\x20call,\x20and\n\x20that\x20the\x20system\ + \x20should\x20return\x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\x05\ + \x04\t\x02\x02\x04\x12\x06\xb2\x03\x02\xad\x03\x16\n\r\n\x05\x04\t\x02\ + \x02\x05\x12\x04\xb2\x03\x02\x08\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xb2\ + \x03\t\x13\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xb2\x03\x16\x17\nA\n\x02\ + \x04\n\x12\x06\xb6\x03\0\xbe\x03\x01\x1a3\x20Response\x20for\x20the\x20`\ + ListTopicSubscriptions`\x20method.\n\n\x0b\n\x03\x04\n\x01\x12\x04\xb6\ + \x03\x08&\nF\n\x04\x04\n\x02\0\x12\x04\xb8\x03\x02$\x1a8\x20The\x20names\ + \x20of\x20the\x20subscriptions\x20that\x20match\x20the\x20request.\n\n\r\ + \n\x05\x04\n\x02\0\x04\x12\x04\xb8\x03\x02\n\n\r\n\x05\x04\n\x02\0\x05\ + \x12\x04\xb8\x03\x0b\x11\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xb8\x03\x12\ + \x1f\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xb8\x03\"#\n\xc7\x01\n\x04\x04\n\ + \x02\x01\x12\x04\xbd\x03\x02\x1d\x1a\xb8\x01\x20If\x20not\x20empty,\x20i\ + ndicates\x20that\x20there\x20may\x20be\x20more\x20subscriptions\x20that\ + \x20match\n\x20the\x20request;\x20this\x20value\x20should\x20be\x20passe\ + d\x20in\x20a\x20new\n\x20`ListTopicSubscriptionsRequest`\x20to\x20get\ + \x20more\x20subscriptions.\n\n\x0f\n\x05\x04\n\x02\x01\x04\x12\x06\xbd\ + \x03\x02\xb8\x03$\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\xbd\x03\x02\x08\n\ + \r\n\x05\x04\n\x02\x01\x01\x12\x04\xbd\x03\t\x18\n\r\n\x05\x04\n\x02\x01\ + \x03\x12\x04\xbd\x03\x1b\x1c\n\x97\x02\n\x02\x04\x0b\x12\x06\xc4\x03\0\ + \xd0\x03\x01\x1a\x88\x02\x20Request\x20for\x20the\x20`ListTopicSnapshots\ + `\x20method.

\n\x20ALPHA:\x20This\x20feature\x20is\x20part\ + \x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\x20be\n\x20cha\ + nged\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\x20recom\ + mended\x20for\x20production\n\x20use.\x20It\x20is\x20not\x20subject\x20t\ + o\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0b\ + \x01\x12\x04\xc4\x03\x08!\nu\n\x04\x04\x0b\x02\0\x12\x04\xc7\x03\x02\x13\ + \x1ag\x20The\x20name\x20of\x20the\x20topic\x20that\x20snapshots\x20are\ + \x20attached\x20to.\n\x20Format\x20is\x20`projects/{project}/topics/{top\ + ic}`.\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\xc7\x03\x02\xc4\x03#\n\r\n\ + \x05\x04\x0b\x02\0\x05\x12\x04\xc7\x03\x02\x08\n\r\n\x05\x04\x0b\x02\0\ + \x01\x12\x04\xc7\x03\t\x0e\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xc7\x03\ + \x11\x12\n;\n\x04\x04\x0b\x02\x01\x12\x04\xca\x03\x02\x16\x1a-\x20Maximu\ + m\x20number\x20of\x20snapshot\x20names\x20to\x20return.\n\n\x0f\n\x05\ + \x04\x0b\x02\x01\x04\x12\x06\xca\x03\x02\xc7\x03\x13\n\r\n\x05\x04\x0b\ + \x02\x01\x05\x12\x04\xca\x03\x02\x07\n\r\n\x05\x04\x0b\x02\x01\x01\x12\ + \x04\xca\x03\x08\x11\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\xca\x03\x14\ + \x15\n\xd4\x01\n\x04\x04\x0b\x02\x02\x12\x04\xcf\x03\x02\x18\x1a\xc5\x01\ + \x20The\x20value\x20returned\x20by\x20the\x20last\x20`ListTopicSnapshots\ + Response`;\x20indicates\n\x20that\x20this\x20is\x20a\x20continuation\x20\ + of\x20a\x20prior\x20`ListTopicSnapshots`\x20call,\x20and\n\x20that\x20th\ + e\x20system\x20should\x20return\x20the\x20next\x20page\x20of\x20data.\n\ + \n\x0f\n\x05\x04\x0b\x02\x02\x04\x12\x06\xcf\x03\x02\xca\x03\x16\n\r\n\ + \x05\x04\x0b\x02\x02\x05\x12\x04\xcf\x03\x02\x08\n\r\n\x05\x04\x0b\x02\ + \x02\x01\x12\x04\xcf\x03\t\x13\n\r\n\x05\x04\x0b\x02\x02\x03\x12\x04\xcf\ + \x03\x16\x17\n\x98\x02\n\x02\x04\x0c\x12\x06\xd6\x03\0\xde\x03\x01\x1a\ + \x89\x02\x20Response\x20for\x20the\x20`ListTopicSnapshots`\x20method.
\n\x20ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\ + \x20alpha\x20release.\x20This\x20API\x20might\x20be\n\x20changed\x20in\ + \x20backward-incompatible\x20ways\x20and\x20is\x20not\x20recommended\x20\ + for\x20production\n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\ + \x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0c\x01\x12\ + \x04\xd6\x03\x08\"\nB\n\x04\x04\x0c\x02\0\x12\x04\xd8\x03\x02\x20\x1a4\ + \x20The\x20names\x20of\x20the\x20snapshots\x20that\x20match\x20the\x20re\ + quest.\n\n\r\n\x05\x04\x0c\x02\0\x04\x12\x04\xd8\x03\x02\n\n\r\n\x05\x04\ + \x0c\x02\0\x05\x12\x04\xd8\x03\x0b\x11\n\r\n\x05\x04\x0c\x02\0\x01\x12\ + \x04\xd8\x03\x12\x1b\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\xd8\x03\x1e\x1f\ + \n\xbb\x01\n\x04\x04\x0c\x02\x01\x12\x04\xdd\x03\x02\x1d\x1a\xac\x01\x20\ + If\x20not\x20empty,\x20indicates\x20that\x20there\x20may\x20be\x20more\ + \x20snapshots\x20that\x20match\n\x20the\x20request;\x20this\x20value\x20\ + should\x20be\x20passed\x20in\x20a\x20new\n\x20`ListTopicSnapshotsRequest\ + `\x20to\x20get\x20more\x20snapshots.\n\n\x0f\n\x05\x04\x0c\x02\x01\x04\ + \x12\x06\xdd\x03\x02\xd8\x03\x20\n\r\n\x05\x04\x0c\x02\x01\x05\x12\x04\ + \xdd\x03\x02\x08\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\xdd\x03\t\x18\n\r\ + \n\x05\x04\x0c\x02\x01\x03\x12\x04\xdd\x03\x1b\x1c\n5\n\x02\x04\r\x12\ + \x06\xe1\x03\0\xe5\x03\x01\x1a'\x20Request\x20for\x20the\x20`DeleteTopic\ + `\x20method.\n\n\x0b\n\x03\x04\r\x01\x12\x04\xe1\x03\x08\x1a\n\\\n\x04\ + \x04\r\x02\0\x12\x04\xe4\x03\x02\x13\x1aN\x20Name\x20of\x20the\x20topic\ + \x20to\x20delete.\n\x20Format\x20is\x20`projects/{project}/topics/{topic\ + }`.\n\n\x0f\n\x05\x04\r\x02\0\x04\x12\x06\xe4\x03\x02\xe1\x03\x1c\n\r\n\ + \x05\x04\r\x02\0\x05\x12\x04\xe4\x03\x02\x08\n\r\n\x05\x04\r\x02\0\x01\ + \x12\x04\xe4\x03\t\x0e\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xe4\x03\x11\x12\ + \n(\n\x02\x04\x0e\x12\x06\xe8\x03\0\xb3\x04\x01\x1a\x1a\x20A\x20subscrip\ + tion\x20resource.\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\xe8\x03\x08\x14\n\ + \x9e\x03\n\x04\x04\x0e\x02\0\x12\x04\xef\x03\x02\x12\x1a\x8f\x03\x20The\ + \x20name\x20of\x20the\x20subscription.\x20It\x20must\x20have\x20the\x20f\ + ormat\n\x20`\"projects/{project}/subscriptions/{subscription}\"`.\x20`{s\ + ubscription}`\x20must\n\x20start\x20with\x20a\x20letter,\x20and\x20conta\ + in\x20only\x20letters\x20(`[A-Za-z]`),\x20numbers\n\x20(`[0-9]`),\x20das\ + hes\x20(`-`),\x20underscores\x20(`_`),\x20periods\x20(`.`),\x20tildes\ + \x20(`~`),\n\x20plus\x20(`+`)\x20or\x20percent\x20signs\x20(`%`).\x20It\ + \x20must\x20be\x20between\x203\x20and\x20255\x20characters\n\x20in\x20le\ + ngth,\x20and\x20it\x20must\x20not\x20start\x20with\x20`\"goog\"`.\n\n\ + \x0f\n\x05\x04\x0e\x02\0\x04\x12\x06\xef\x03\x02\xe8\x03\x16\n\r\n\x05\ + \x04\x0e\x02\0\x05\x12\x04\xef\x03\x02\x08\n\r\n\x05\x04\x0e\x02\0\x01\ + \x12\x04\xef\x03\t\r\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xef\x03\x10\x11\ + \n\xdd\x01\n\x04\x04\x0e\x02\x01\x12\x04\xf5\x03\x02\x13\x1a\xce\x01\x20\ + The\x20name\x20of\x20the\x20topic\x20from\x20which\x20this\x20subscripti\ + on\x20is\x20receiving\x20messages.\n\x20Format\x20is\x20`projects/{proje\ + ct}/topics/{topic}`.\n\x20The\x20value\x20of\x20this\x20field\x20will\ + \x20be\x20`_deleted-topic_`\x20if\x20the\x20topic\x20has\x20been\n\x20de\ + leted.\n\n\x0f\n\x05\x04\x0e\x02\x01\x04\x12\x06\xf5\x03\x02\xef\x03\x12\ + \n\r\n\x05\x04\x0e\x02\x01\x05\x12\x04\xf5\x03\x02\x08\n\r\n\x05\x04\x0e\ + \x02\x01\x01\x12\x04\xf5\x03\t\x0e\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\ + \xf5\x03\x11\x12\n\xc9\x01\n\x04\x04\x0e\x02\x02\x12\x04\xfa\x03\x02\x1d\ + \x1a\xba\x01\x20If\x20push\x20delivery\x20is\x20used\x20with\x20this\x20\ + subscription,\x20this\x20field\x20is\n\x20used\x20to\x20configure\x20it.\ + \x20An\x20empty\x20`pushConfig`\x20signifies\x20that\x20the\x20subscribe\ + r\n\x20will\x20pull\x20and\x20ack\x20messages\x20using\x20API\x20methods\ + .\n\n\x0f\n\x05\x04\x0e\x02\x02\x04\x12\x06\xfa\x03\x02\xf5\x03\x13\n\r\ + \n\x05\x04\x0e\x02\x02\x06\x12\x04\xfa\x03\x02\x0c\n\r\n\x05\x04\x0e\x02\ + \x02\x01\x12\x04\xfa\x03\r\x18\n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\xfa\ + \x03\x1b\x1c\n\xaf\x08\n\x04\x04\x0e\x02\x03\x12\x04\x90\x04\x02!\x1a\ + \xa0\x08\x20This\x20value\x20is\x20the\x20maximum\x20time\x20after\x20a\ + \x20subscriber\x20receives\x20a\x20message\n\x20before\x20the\x20subscri\ + ber\x20should\x20acknowledge\x20the\x20message.\x20After\x20message\n\ + \x20delivery\x20but\x20before\x20the\x20ack\x20deadline\x20expires\x20an\ + d\x20before\x20the\x20message\x20is\n\x20acknowledged,\x20it\x20is\x20an\ + \x20outstanding\x20message\x20and\x20will\x20not\x20be\x20delivered\n\ + \x20again\x20during\x20that\x20time\x20(on\x20a\x20best-effort\x20basis)\ + .\n\n\x20For\x20pull\x20subscriptions,\x20this\x20value\x20is\x20used\ + \x20as\x20the\x20initial\x20value\x20for\x20the\x20ack\n\x20deadline.\ + \x20To\x20override\x20this\x20value\x20for\x20a\x20given\x20message,\x20\ + call\n\x20`ModifyAckDeadline`\x20with\x20the\x20corresponding\x20`ack_id\ + `\x20if\x20using\n\x20non-streaming\x20pull\x20or\x20send\x20the\x20`ack\ + _id`\x20in\x20a\n\x20`StreamingModifyAckDeadlineRequest`\x20if\x20using\ + \x20streaming\x20pull.\n\x20The\x20minimum\x20custom\x20deadline\x20you\ + \x20can\x20specify\x20is\x2010\x20seconds.\n\x20The\x20maximum\x20custom\ + \x20deadline\x20you\x20can\x20specify\x20is\x20600\x20seconds\x20(10\x20\ + minutes).\n\x20If\x20this\x20parameter\x20is\x200,\x20a\x20default\x20va\ + lue\x20of\x2010\x20seconds\x20is\x20used.\n\n\x20For\x20push\x20delivery\ + ,\x20this\x20value\x20is\x20also\x20used\x20to\x20set\x20the\x20request\ + \x20timeout\x20for\n\x20the\x20call\x20to\x20the\x20push\x20endpoint.\n\ + \n\x20If\x20the\x20subscriber\x20never\x20acknowledges\x20the\x20message\ + ,\x20the\x20Pub/Sub\n\x20system\x20will\x20eventually\x20redeliver\x20th\ + e\x20message.\n\n\x0f\n\x05\x04\x0e\x02\x03\x04\x12\x06\x90\x04\x02\xfa\ + \x03\x1d\n\r\n\x05\x04\x0e\x02\x03\x05\x12\x04\x90\x04\x02\x07\n\r\n\x05\ + \x04\x0e\x02\x03\x01\x12\x04\x90\x04\x08\x1c\n\r\n\x05\x04\x0e\x02\x03\ + \x03\x12\x04\x90\x04\x1f\x20\n\xc8\x03\n\x04\x04\x0e\x02\x04\x12\x04\x99\ + \x04\x02!\x1a\xb9\x03\x20Indicates\x20whether\x20to\x20retain\x20acknowl\ + edged\x20messages.\x20If\x20true,\x20then\n\x20messages\x20are\x20not\ + \x20expunged\x20from\x20the\x20subscription's\x20backlog,\x20even\x20if\ + \x20they\x20are\n\x20acknowledged,\x20until\x20they\x20fall\x20out\x20of\ + \x20the\x20`message_retention_duration`\n\x20window.

\n\x20ALP\ + HA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\x20release\ + .\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backward-incompati\ + ble\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20production\n\ + \x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20depr\ + ecation\x20policy.\n\n\x0f\n\x05\x04\x0e\x02\x04\x04\x12\x06\x99\x04\x02\ + \x90\x04!\n\r\n\x05\x04\x0e\x02\x04\x05\x12\x04\x99\x04\x02\x06\n\r\n\ + \x05\x04\x0e\x02\x04\x01\x12\x04\x99\x04\x07\x1c\n\r\n\x05\x04\x0e\x02\ + \x04\x03\x12\x04\x99\x04\x1f\x20\n\xce\x04\n\x04\x04\x0e\x02\x05\x12\x04\ + \xa4\x04\x02:\x1a\xbf\x04\x20How\x20long\x20to\x20retain\x20unacknowledg\ + ed\x20messages\x20in\x20the\x20subscription's\x20backlog,\n\x20from\x20t\ + he\x20moment\x20a\x20message\x20is\x20published.\n\x20If\x20`retain_acke\ + d_messages`\x20is\x20true,\x20then\x20this\x20also\x20configures\x20the\ + \x20retention\n\x20of\x20acknowledged\x20messages,\x20and\x20thus\x20con\ + figures\x20how\x20far\x20back\x20in\x20time\x20a\x20`Seek`\n\x20can\x20b\ + e\x20done.\x20Defaults\x20to\x207\x20days.\x20Cannot\x20be\x20more\x20th\ + an\x207\x20days\x20or\x20less\x20than\x2010\n\x20minutes.

\n\x20<\ + b>ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\x20re\ + lease.\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backward-inco\ + mpatible\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20production\ + \n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20de\ + precation\x20policy.\n\n\x0f\n\x05\x04\x0e\x02\x05\x04\x12\x06\xa4\x04\ + \x02\x99\x04!\n\r\n\x05\x04\x0e\x02\x05\x06\x12\x04\xa4\x04\x02\x1a\n\r\ + \n\x05\x04\x0e\x02\x05\x01\x12\x04\xa4\x04\x1b5\n\r\n\x05\x04\x0e\x02\ + \x05\x03\x12\x04\xa4\x0489\nT\n\x04\x04\x0e\x02\x06\x12\x04\xa7\x04\x02!\ + \x1aF\x20See\x20\x20Creating\x20and\ + \x20managing\x20labels.\n\n\x0f\n\x05\x04\x0e\x02\x06\x04\x12\x06\ + \xa7\x04\x02\xa4\x04:\n\r\n\x05\x04\x0e\x02\x06\x06\x12\x04\xa7\x04\x02\ + \x15\n\r\n\x05\x04\x0e\x02\x06\x01\x12\x04\xa7\x04\x16\x1c\n\r\n\x05\x04\ + \x0e\x02\x06\x03\x12\x04\xa7\x04\x1f\x20\n\xf8\x04\n\x04\x04\x0e\x02\x07\ + \x12\x04\xb2\x04\x02*\x1a\xe9\x04\x20A\x20policy\x20that\x20specifies\ + \x20the\x20conditions\x20for\x20this\x20subscription's\x20expiration.\n\ + \x20A\x20subscription\x20is\x20considered\x20active\x20as\x20long\x20as\ + \x20any\x20connected\x20subscriber\x20is\n\x20successfully\x20consuming\ + \x20messages\x20from\x20the\x20subscription\x20or\x20is\x20issuing\n\x20\ + operations\x20on\x20the\x20subscription.\x20If\x20`expiration_policy`\ + \x20is\x20not\x20set,\x20a\n\x20*default\x20policy*\x20with\x20`ttl`\x20\ + of\x2031\x20days\x20will\x20be\x20used.\x20The\x20minimum\x20allowed\n\ + \x20value\x20for\x20`expiration_policy.ttl`\x20is\x201\x20day.\n\x20B\ + ETA:\x20This\x20feature\x20is\x20part\x20of\x20a\x20beta\x20release.\ + \x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backward-incompatib\ + le\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20production\n\x20\ + use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecat\ + ion\x20policy.\n\n\x0f\n\x05\x04\x0e\x02\x07\x04\x12\x06\xb2\x04\x02\xa7\ + \x04!\n\r\n\x05\x04\x0e\x02\x07\x06\x12\x04\xb2\x04\x02\x12\n\r\n\x05\ + \x04\x0e\x02\x07\x01\x12\x04\xb2\x04\x13$\n\r\n\x05\x04\x0e\x02\x07\x03\ + \x12\x04\xb2\x04')\nt\n\x02\x04\x0f\x12\x06\xb7\x04\0\xbf\x04\x01\x1af\ + \x20A\x20policy\x20that\x20specifies\x20the\x20conditions\x20for\x20reso\ + urce\x20expiration\x20(i.e.,\n\x20automatic\x20resource\x20deletion).\n\ + \n\x0b\n\x03\x04\x0f\x01\x12\x04\xb7\x04\x08\x18\n\x89\x03\n\x04\x04\x0f\ + \x02\0\x12\x04\xbe\x04\x02#\x1a\xfa\x02\x20Specifies\x20the\x20\"time-to\ + -live\"\x20duration\x20for\x20an\x20associated\x20resource.\x20The\n\x20\ + resource\x20expires\x20if\x20it\x20is\x20not\x20active\x20for\x20a\x20pe\ + riod\x20of\x20`ttl`.\x20The\x20definition\n\x20of\x20\"activity\"\x20dep\ + ends\x20on\x20the\x20type\x20of\x20the\x20associated\x20resource.\x20The\ + \x20minimum\n\x20and\x20maximum\x20allowed\x20values\x20for\x20`ttl`\x20\ + depend\x20on\x20the\x20type\x20of\x20the\x20associated\n\x20resource,\ + \x20as\x20well.\x20If\x20`ttl`\x20is\x20not\x20set,\x20the\x20associated\ + \x20resource\x20never\n\x20expires.\n\n\x0f\n\x05\x04\x0f\x02\0\x04\x12\ + \x06\xbe\x04\x02\xb7\x04\x1a\n\r\n\x05\x04\x0f\x02\0\x06\x12\x04\xbe\x04\ + \x02\x1a\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\xbe\x04\x1b\x1e\n\r\n\x05\ + \x04\x0f\x02\0\x03\x12\x04\xbe\x04!\"\n;\n\x02\x04\x10\x12\x06\xc2\x04\0\ + \xdd\x04\x01\x1a-\x20Configuration\x20for\x20a\x20push\x20delivery\x20en\ + dpoint.\n\n\x0b\n\x03\x04\x10\x01\x12\x04\xc2\x04\x08\x12\n\x97\x01\n\ + \x04\x04\x10\x02\0\x12\x04\xc5\x04\x02\x1b\x1a\x88\x01\x20A\x20URL\x20lo\ + cating\x20the\x20endpoint\x20to\x20which\x20messages\x20should\x20be\x20\ + pushed.\n\x20For\x20example,\x20a\x20Webhook\x20endpoint\x20might\x20use\ + \x20\"https://example.com/push\".\n\n\x0f\n\x05\x04\x10\x02\0\x04\x12\ + \x06\xc5\x04\x02\xc2\x04\x14\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\xc5\x04\ + \x02\x08\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\xc5\x04\t\x16\n\r\n\x05\x04\ + \x10\x02\0\x03\x12\x04\xc5\x04\x19\x1a\n\x8e\x08\n\x04\x04\x10\x02\x01\ + \x12\x04\xdc\x04\x02%\x1a\xff\x07\x20Endpoint\x20configuration\x20attrib\ + utes.\n\n\x20Every\x20endpoint\x20has\x20a\x20set\x20of\x20API\x20suppor\ + ted\x20attributes\x20that\x20can\x20be\x20used\x20to\n\x20control\x20dif\ + ferent\x20aspects\x20of\x20the\x20message\x20delivery.\n\n\x20The\x20cur\ + rently\x20supported\x20attribute\x20is\x20`x-goog-version`,\x20which\x20\ + you\x20can\n\x20use\x20to\x20change\x20the\x20format\x20of\x20the\x20pus\ + hed\x20message.\x20This\x20attribute\n\x20indicates\x20the\x20version\ + \x20of\x20the\x20data\x20expected\x20by\x20the\x20endpoint.\x20This\n\ + \x20controls\x20the\x20shape\x20of\x20the\x20pushed\x20message\x20(i.e.,\ + \x20its\x20fields\x20and\x20metadata).\n\x20The\x20endpoint\x20version\ + \x20is\x20based\x20on\x20the\x20version\x20of\x20the\x20Pub/Sub\x20API.\ + \n\n\x20If\x20not\x20present\x20during\x20the\x20`CreateSubscription`\ + \x20call,\x20it\x20will\x20default\x20to\n\x20the\x20version\x20of\x20th\ + e\x20API\x20used\x20to\x20make\x20such\x20call.\x20If\x20not\x20present\ + \x20during\x20a\n\x20`ModifyPushConfig`\x20call,\x20its\x20value\x20will\ + \x20not\x20be\x20changed.\x20`GetSubscription`\n\x20calls\x20will\x20alw\ + ays\x20return\x20a\x20valid\x20version,\x20even\x20if\x20the\x20subscrip\ + tion\x20was\n\x20created\x20without\x20this\x20attribute.\n\n\x20The\x20\ + possible\x20values\x20for\x20this\x20attribute\x20are:\n\n\x20*\x20`v1be\ + ta1`:\x20uses\x20the\x20push\x20format\x20defined\x20in\x20the\x20v1beta\ + 1\x20Pub/Sub\x20API.\n\x20*\x20`v1`\x20or\x20`v1beta2`:\x20uses\x20the\ + \x20push\x20format\x20defined\x20in\x20the\x20v1\x20Pub/Sub\x20API.\n\n\ + \x0f\n\x05\x04\x10\x02\x01\x04\x12\x06\xdc\x04\x02\xc5\x04\x1b\n\r\n\x05\ + \x04\x10\x02\x01\x06\x12\x04\xdc\x04\x02\x15\n\r\n\x05\x04\x10\x02\x01\ + \x01\x12\x04\xdc\x04\x16\x20\n\r\n\x05\x04\x10\x02\x01\x03\x12\x04\xdc\ + \x04#$\nB\n\x02\x04\x11\x12\x06\xe0\x04\0\xe6\x04\x01\x1a4\x20A\x20messa\ + ge\x20and\x20its\x20corresponding\x20acknowledgment\x20ID.\n\n\x0b\n\x03\ + \x04\x11\x01\x12\x04\xe0\x04\x08\x17\nH\n\x04\x04\x11\x02\0\x12\x04\xe2\ + \x04\x02\x14\x1a:\x20This\x20ID\x20can\x20be\x20used\x20to\x20acknowledg\ + e\x20the\x20received\x20message.\n\n\x0f\n\x05\x04\x11\x02\0\x04\x12\x06\ + \xe2\x04\x02\xe0\x04\x19\n\r\n\x05\x04\x11\x02\0\x05\x12\x04\xe2\x04\x02\ + \x08\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\xe2\x04\t\x0f\n\r\n\x05\x04\x11\ + \x02\0\x03\x12\x04\xe2\x04\x12\x13\n\x1c\n\x04\x04\x11\x02\x01\x12\x04\ + \xe5\x04\x02\x1c\x1a\x0e\x20The\x20message.\n\n\x0f\n\x05\x04\x11\x02\ + \x01\x04\x12\x06\xe5\x04\x02\xe2\x04\x14\n\r\n\x05\x04\x11\x02\x01\x06\ + \x12\x04\xe5\x04\x02\x0f\n\r\n\x05\x04\x11\x02\x01\x01\x12\x04\xe5\x04\ + \x10\x17\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xe5\x04\x1a\x1b\n7\n\x02\ + \x04\x12\x12\x06\xe9\x04\0\xed\x04\x01\x1a)\x20Request\x20for\x20the\x20\ + GetSubscription\x20method.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\xe9\x04\x08\ + \x1e\ni\n\x04\x04\x12\x02\0\x12\x04\xec\x04\x02\x1a\x1a[\x20The\x20name\ + \x20of\x20the\x20subscription\x20to\x20get.\n\x20Format\x20is\x20`projec\ + ts/{project}/subscriptions/{sub}`.\n\n\x0f\n\x05\x04\x12\x02\0\x04\x12\ + \x06\xec\x04\x02\xe9\x04\x20\n\r\n\x05\x04\x12\x02\0\x05\x12\x04\xec\x04\ + \x02\x08\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\xec\x04\t\x15\n\r\n\x05\x04\ + \x12\x02\0\x03\x12\x04\xec\x04\x18\x19\n:\n\x02\x04\x13\x12\x06\xf0\x04\ + \0\xf7\x04\x01\x1a,\x20Request\x20for\x20the\x20UpdateSubscription\x20me\ + thod.\n\n\x0b\n\x03\x04\x13\x01\x12\x04\xf0\x04\x08!\n0\n\x04\x04\x13\ + \x02\0\x12\x04\xf2\x04\x02\x20\x1a\"\x20The\x20updated\x20subscription\ + \x20object.\n\n\x0f\n\x05\x04\x13\x02\0\x04\x12\x06\xf2\x04\x02\xf0\x04#\ + \n\r\n\x05\x04\x13\x02\0\x06\x12\x04\xf2\x04\x02\x0e\n\r\n\x05\x04\x13\ + \x02\0\x01\x12\x04\xf2\x04\x0f\x1b\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\ + \xf2\x04\x1e\x1f\np\n\x04\x04\x13\x02\x01\x12\x04\xf6\x04\x02,\x1ab\x20I\ + ndicates\x20which\x20fields\x20in\x20the\x20provided\x20subscription\x20\ + to\x20update.\n\x20Must\x20be\x20specified\x20and\x20non-empty.\n\n\x0f\ + \n\x05\x04\x13\x02\x01\x04\x12\x06\xf6\x04\x02\xf2\x04\x20\n\r\n\x05\x04\ + \x13\x02\x01\x06\x12\x04\xf6\x04\x02\x1b\n\r\n\x05\x04\x13\x02\x01\x01\ + \x12\x04\xf6\x04\x1c'\n\r\n\x05\x04\x13\x02\x01\x03\x12\x04\xf6\x04*+\n;\ + \n\x02\x04\x14\x12\x06\xfa\x04\0\x86\x05\x01\x1a-\x20Request\x20for\x20t\ + he\x20`ListSubscriptions`\x20method.\n\n\x0b\n\x03\x04\x14\x01\x12\x04\ + \xfa\x04\x08\x20\nk\n\x04\x04\x14\x02\0\x12\x04\xfd\x04\x02\x15\x1a]\x20\ + The\x20name\x20of\x20the\x20project\x20in\x20which\x20to\x20list\x20subs\ + criptions.\n\x20Format\x20is\x20`projects/{project-id}`.\n\n\x0f\n\x05\ + \x04\x14\x02\0\x04\x12\x06\xfd\x04\x02\xfa\x04\"\n\r\n\x05\x04\x14\x02\0\ + \x05\x12\x04\xfd\x04\x02\x08\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\xfd\x04\ + \t\x10\n\r\n\x05\x04\x14\x02\0\x03\x12\x04\xfd\x04\x13\x14\n:\n\x04\x04\ + \x14\x02\x01\x12\x04\x80\x05\x02\x16\x1a,\x20Maximum\x20number\x20of\x20\ + subscriptions\x20to\x20return.\n\n\x0f\n\x05\x04\x14\x02\x01\x04\x12\x06\ + \x80\x05\x02\xfd\x04\x15\n\r\n\x05\x04\x14\x02\x01\x05\x12\x04\x80\x05\ + \x02\x07\n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\x80\x05\x08\x11\n\r\n\x05\ + \x04\x14\x02\x01\x03\x12\x04\x80\x05\x14\x15\n\xd2\x01\n\x04\x04\x14\x02\ + \x02\x12\x04\x85\x05\x02\x18\x1a\xc3\x01\x20The\x20value\x20returned\x20\ + by\x20the\x20last\x20`ListSubscriptionsResponse`;\x20indicates\x20that\n\ + \x20this\x20is\x20a\x20continuation\x20of\x20a\x20prior\x20`ListSubscrip\ + tions`\x20call,\x20and\x20that\x20the\n\x20system\x20should\x20return\ + \x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\x05\x04\x14\x02\x02\x04\ + \x12\x06\x85\x05\x02\x80\x05\x16\n\r\n\x05\x04\x14\x02\x02\x05\x12\x04\ + \x85\x05\x02\x08\n\r\n\x05\x04\x14\x02\x02\x01\x12\x04\x85\x05\t\x13\n\r\ + \n\x05\x04\x14\x02\x02\x03\x12\x04\x85\x05\x16\x17\n<\n\x02\x04\x15\x12\ + \x06\x89\x05\0\x91\x05\x01\x1a.\x20Response\x20for\x20the\x20`ListSubscr\ + iptions`\x20method.\n\n\x0b\n\x03\x04\x15\x01\x12\x04\x89\x05\x08!\n9\n\ + \x04\x04\x15\x02\0\x12\x04\x8b\x05\x02*\x1a+\x20The\x20subscriptions\x20\ + that\x20match\x20the\x20request.\n\n\r\n\x05\x04\x15\x02\0\x04\x12\x04\ + \x8b\x05\x02\n\n\r\n\x05\x04\x15\x02\0\x06\x12\x04\x8b\x05\x0b\x17\n\r\n\ + \x05\x04\x15\x02\0\x01\x12\x04\x8b\x05\x18%\n\r\n\x05\x04\x15\x02\0\x03\ + \x12\x04\x8b\x05()\n\xc2\x01\n\x04\x04\x15\x02\x01\x12\x04\x90\x05\x02\ + \x1d\x1a\xb3\x01\x20If\x20not\x20empty,\x20indicates\x20that\x20there\ + \x20may\x20be\x20more\x20subscriptions\x20that\x20match\n\x20the\x20requ\ + est;\x20this\x20value\x20should\x20be\x20passed\x20in\x20a\x20new\n\x20`\ + ListSubscriptionsRequest`\x20to\x20get\x20more\x20subscriptions.\n\n\x0f\ + \n\x05\x04\x15\x02\x01\x04\x12\x06\x90\x05\x02\x8b\x05*\n\r\n\x05\x04\ + \x15\x02\x01\x05\x12\x04\x90\x05\x02\x08\n\r\n\x05\x04\x15\x02\x01\x01\ + \x12\x04\x90\x05\t\x18\n\r\n\x05\x04\x15\x02\x01\x03\x12\x04\x90\x05\x1b\ + \x1c\n:\n\x02\x04\x16\x12\x06\x94\x05\0\x98\x05\x01\x1a,\x20Request\x20f\ + or\x20the\x20DeleteSubscription\x20method.\n\n\x0b\n\x03\x04\x16\x01\x12\ + \x04\x94\x05\x08!\n`\n\x04\x04\x16\x02\0\x12\x04\x97\x05\x02\x1a\x1aR\ + \x20The\x20subscription\x20to\x20delete.\n\x20Format\x20is\x20`projects/\ + {project}/subscriptions/{sub}`.\n\n\x0f\n\x05\x04\x16\x02\0\x04\x12\x06\ + \x97\x05\x02\x94\x05#\n\r\n\x05\x04\x16\x02\0\x05\x12\x04\x97\x05\x02\ + \x08\n\r\n\x05\x04\x16\x02\0\x01\x12\x04\x97\x05\t\x15\n\r\n\x05\x04\x16\ + \x02\0\x03\x12\x04\x97\x05\x18\x19\n8\n\x02\x04\x17\x12\x06\x9b\x05\0\ + \xa7\x05\x01\x1a*\x20Request\x20for\x20the\x20ModifyPushConfig\x20method\ + .\n\n\x0b\n\x03\x04\x17\x01\x12\x04\x9b\x05\x08\x1f\nb\n\x04\x04\x17\x02\ + \0\x12\x04\x9e\x05\x02\x1a\x1aT\x20The\x20name\x20of\x20the\x20subscript\ + ion.\n\x20Format\x20is\x20`projects/{project}/subscriptions/{sub}`.\n\n\ + \x0f\n\x05\x04\x17\x02\0\x04\x12\x06\x9e\x05\x02\x9b\x05!\n\r\n\x05\x04\ + \x17\x02\0\x05\x12\x04\x9e\x05\x02\x08\n\r\n\x05\x04\x17\x02\0\x01\x12\ + \x04\x9e\x05\t\x15\n\r\n\x05\x04\x17\x02\0\x03\x12\x04\x9e\x05\x18\x19\n\ + \xb8\x02\n\x04\x04\x17\x02\x01\x12\x04\xa6\x05\x02\x1d\x1a\xa9\x02\x20Th\ + e\x20push\x20configuration\x20for\x20future\x20deliveries.\n\n\x20An\x20\ + empty\x20`pushConfig`\x20indicates\x20that\x20the\x20Pub/Sub\x20system\ + \x20should\n\x20stop\x20pushing\x20messages\x20from\x20the\x20given\x20s\ + ubscription\x20and\x20allow\n\x20messages\x20to\x20be\x20pulled\x20and\ + \x20acknowledged\x20-\x20effectively\x20pausing\n\x20the\x20subscription\ + \x20if\x20`Pull`\x20or\x20`StreamingPull`\x20is\x20not\x20called.\n\n\ + \x0f\n\x05\x04\x17\x02\x01\x04\x12\x06\xa6\x05\x02\x9e\x05\x1a\n\r\n\x05\ + \x04\x17\x02\x01\x06\x12\x04\xa6\x05\x02\x0c\n\r\n\x05\x04\x17\x02\x01\ + \x01\x12\x04\xa6\x05\r\x18\n\r\n\x05\x04\x17\x02\x01\x03\x12\x04\xa6\x05\ + \x1b\x1c\n.\n\x02\x04\x18\x12\x06\xaa\x05\0\xb8\x05\x01\x1a\x20\x20Reque\ + st\x20for\x20the\x20`Pull`\x20method.\n\n\x0b\n\x03\x04\x18\x01\x12\x04\ + \xaa\x05\x08\x13\n{\n\x04\x04\x18\x02\0\x12\x04\xad\x05\x02\x1a\x1am\x20\ + The\x20subscription\x20from\x20which\x20messages\x20should\x20be\x20pull\ + ed.\n\x20Format\x20is\x20`projects/{project}/subscriptions/{sub}`.\n\n\ + \x0f\n\x05\x04\x18\x02\0\x04\x12\x06\xad\x05\x02\xaa\x05\x15\n\r\n\x05\ + \x04\x18\x02\0\x05\x12\x04\xad\x05\x02\x08\n\r\n\x05\x04\x18\x02\0\x01\ + \x12\x04\xad\x05\t\x15\n\r\n\x05\x04\x18\x02\0\x03\x12\x04\xad\x05\x18\ + \x19\n\xa9\x02\n\x04\x04\x18\x02\x01\x12\x04\xb3\x05\x02\x1e\x1a\x9a\x02\ + \x20If\x20this\x20field\x20set\x20to\x20true,\x20the\x20system\x20will\ + \x20respond\x20immediately\x20even\x20if\n\x20it\x20there\x20are\x20no\ + \x20messages\x20available\x20to\x20return\x20in\x20the\x20`Pull`\x20resp\ + onse.\n\x20Otherwise,\x20the\x20system\x20may\x20wait\x20(for\x20a\x20bo\ + unded\x20amount\x20of\x20time)\x20until\x20at\n\x20least\x20one\x20messa\ + ge\x20is\x20available,\x20rather\x20than\x20returning\x20no\x20messages.\ + \n\n\x0f\n\x05\x04\x18\x02\x01\x04\x12\x06\xb3\x05\x02\xad\x05\x1a\n\r\n\ + \x05\x04\x18\x02\x01\x05\x12\x04\xb3\x05\x02\x06\n\r\n\x05\x04\x18\x02\ + \x01\x01\x12\x04\xb3\x05\x07\x19\n\r\n\x05\x04\x18\x02\x01\x03\x12\x04\ + \xb3\x05\x1c\x1d\n\x89\x01\n\x04\x04\x18\x02\x02\x12\x04\xb7\x05\x02\x19\ + \x1a{\x20The\x20maximum\x20number\x20of\x20messages\x20returned\x20for\ + \x20this\x20request.\x20The\x20Pub/Sub\n\x20system\x20may\x20return\x20f\ + ewer\x20than\x20the\x20number\x20specified.\n\n\x0f\n\x05\x04\x18\x02\ + \x02\x04\x12\x06\xb7\x05\x02\xb3\x05\x1e\n\r\n\x05\x04\x18\x02\x02\x05\ + \x12\x04\xb7\x05\x02\x07\n\r\n\x05\x04\x18\x02\x02\x01\x12\x04\xb7\x05\ + \x08\x14\n\r\n\x05\x04\x18\x02\x02\x03\x12\x04\xb7\x05\x17\x18\n/\n\x02\ + \x04\x19\x12\x06\xbb\x05\0\xc1\x05\x01\x1a!\x20Response\x20for\x20the\ + \x20`Pull`\x20method.\n\n\x0b\n\x03\x04\x19\x01\x12\x04\xbb\x05\x08\x14\ + \n\xaa\x02\n\x04\x04\x19\x02\0\x12\x04\xc0\x05\x021\x1a\x9b\x02\x20Recei\ + ved\x20Pub/Sub\x20messages.\x20The\x20list\x20will\x20be\x20empty\x20if\ + \x20there\x20are\x20no\x20more\n\x20messages\x20available\x20in\x20the\ + \x20backlog.\x20For\x20JSON,\x20the\x20response\x20can\x20be\x20entirely\ + \n\x20empty.\x20The\x20Pub/Sub\x20system\x20may\x20return\x20fewer\x20th\ + an\x20the\x20`maxMessages`\x20requested\n\x20even\x20if\x20there\x20are\ + \x20more\x20messages\x20available\x20in\x20the\x20backlog.\n\n\r\n\x05\ + \x04\x19\x02\0\x04\x12\x04\xc0\x05\x02\n\n\r\n\x05\x04\x19\x02\0\x06\x12\ + \x04\xc0\x05\x0b\x1a\n\r\n\x05\x04\x19\x02\0\x01\x12\x04\xc0\x05\x1b,\n\ + \r\n\x05\x04\x19\x02\0\x03\x12\x04\xc0\x05/0\n9\n\x02\x04\x1a\x12\x06\ + \xc4\x05\0\xd4\x05\x01\x1a+\x20Request\x20for\x20the\x20ModifyAckDeadlin\ + e\x20method.\n\n\x0b\n\x03\x04\x1a\x01\x12\x04\xc4\x05\x08\x20\nb\n\x04\ + \x04\x1a\x02\0\x12\x04\xc7\x05\x02\x1a\x1aT\x20The\x20name\x20of\x20the\ + \x20subscription.\n\x20Format\x20is\x20`projects/{project}/subscriptions\ + /{sub}`.\n\n\x0f\n\x05\x04\x1a\x02\0\x04\x12\x06\xc7\x05\x02\xc4\x05\"\n\ + \r\n\x05\x04\x1a\x02\0\x05\x12\x04\xc7\x05\x02\x08\n\r\n\x05\x04\x1a\x02\ + \0\x01\x12\x04\xc7\x05\t\x15\n\r\n\x05\x04\x1a\x02\0\x03\x12\x04\xc7\x05\ + \x18\x19\n+\n\x04\x04\x1a\x02\x01\x12\x04\xca\x05\x02\x1e\x1a\x1d\x20Lis\ + t\x20of\x20acknowledgment\x20IDs.\n\n\r\n\x05\x04\x1a\x02\x01\x04\x12\ + \x04\xca\x05\x02\n\n\r\n\x05\x04\x1a\x02\x01\x05\x12\x04\xca\x05\x0b\x11\ + \n\r\n\x05\x04\x1a\x02\x01\x01\x12\x04\xca\x05\x12\x19\n\r\n\x05\x04\x1a\ + \x02\x01\x03\x12\x04\xca\x05\x1c\x1d\n\xb5\x03\n\x04\x04\x1a\x02\x02\x12\ + \x04\xd3\x05\x02!\x1a\xa6\x03\x20The\x20new\x20ack\x20deadline\x20with\ + \x20respect\x20to\x20the\x20time\x20this\x20request\x20was\x20sent\x20to\ + \n\x20the\x20Pub/Sub\x20system.\x20For\x20example,\x20if\x20the\x20value\ + \x20is\x2010,\x20the\x20new\n\x20ack\x20deadline\x20will\x20expire\x2010\ + \x20seconds\x20after\x20the\x20`ModifyAckDeadline`\x20call\n\x20was\x20m\ + ade.\x20Specifying\x20zero\x20may\x20immediately\x20make\x20the\x20messa\ + ge\x20available\x20for\n\x20another\x20pull\x20request.\n\x20The\x20mini\ + mum\x20deadline\x20you\x20can\x20specify\x20is\x200\x20seconds.\n\x20The\ + \x20maximum\x20deadline\x20you\x20can\x20specify\x20is\x20600\x20seconds\ + \x20(10\x20minutes).\n\n\x0f\n\x05\x04\x1a\x02\x02\x04\x12\x06\xd3\x05\ + \x02\xca\x05\x1e\n\r\n\x05\x04\x1a\x02\x02\x05\x12\x04\xd3\x05\x02\x07\n\ + \r\n\x05\x04\x1a\x02\x02\x01\x12\x04\xd3\x05\x08\x1c\n\r\n\x05\x04\x1a\ + \x02\x02\x03\x12\x04\xd3\x05\x1f\x20\n3\n\x02\x04\x1b\x12\x06\xd7\x05\0\ + \xdf\x05\x01\x1a%\x20Request\x20for\x20the\x20Acknowledge\x20method.\n\n\ + \x0b\n\x03\x04\x1b\x01\x12\x04\xd7\x05\x08\x1a\nz\n\x04\x04\x1b\x02\0\ + \x12\x04\xda\x05\x02\x1a\x1al\x20The\x20subscription\x20whose\x20message\ + \x20is\x20being\x20acknowledged.\n\x20Format\x20is\x20`projects/{project\ + }/subscriptions/{sub}`.\n\n\x0f\n\x05\x04\x1b\x02\0\x04\x12\x06\xda\x05\ + \x02\xd7\x05\x1c\n\r\n\x05\x04\x1b\x02\0\x05\x12\x04\xda\x05\x02\x08\n\r\ + \n\x05\x04\x1b\x02\0\x01\x12\x04\xda\x05\t\x15\n\r\n\x05\x04\x1b\x02\0\ + \x03\x12\x04\xda\x05\x18\x19\n\x9e\x01\n\x04\x04\x1b\x02\x01\x12\x04\xde\ + \x05\x02\x1e\x1a\x8f\x01\x20The\x20acknowledgment\x20ID\x20for\x20the\ + \x20messages\x20being\x20acknowledged\x20that\x20was\x20returned\n\x20by\ + \x20the\x20Pub/Sub\x20system\x20in\x20the\x20`Pull`\x20response.\x20Must\ + \x20not\x20be\x20empty.\n\n\r\n\x05\x04\x1b\x02\x01\x04\x12\x04\xde\x05\ + \x02\n\n\r\n\x05\x04\x1b\x02\x01\x05\x12\x04\xde\x05\x0b\x11\n\r\n\x05\ + \x04\x1b\x02\x01\x01\x12\x04\xde\x05\x12\x19\n\r\n\x05\x04\x1b\x02\x01\ + \x03\x12\x04\xde\x05\x1c\x1d\n\xe1\x01\n\x02\x04\x1c\x12\x06\xe4\x05\0\ + \x8b\x06\x01\x1a\xd2\x01\x20Request\x20for\x20the\x20`StreamingPull`\x20\ + streaming\x20RPC\x20method.\x20This\x20request\x20is\x20used\x20to\n\x20\ + establish\x20the\x20initial\x20stream\x20as\x20well\x20as\x20to\x20strea\ + m\x20acknowledgements\x20and\x20ack\n\x20deadline\x20modifications\x20fr\ + om\x20the\x20client\x20to\x20the\x20server.\n\n\x0b\n\x03\x04\x1c\x01\ + \x12\x04\xe4\x05\x08\x1c\n\xfc\x01\n\x04\x04\x1c\x02\0\x12\x04\xe9\x05\ + \x02\x1a\x1a\xed\x01\x20The\x20subscription\x20for\x20which\x20to\x20ini\ + tialize\x20the\x20new\x20stream.\x20This\x20must\x20be\n\x20provided\x20\ + in\x20the\x20first\x20request\x20on\x20the\x20stream,\x20and\x20must\x20\ + not\x20be\x20set\x20in\n\x20subsequent\x20requests\x20from\x20client\x20\ + to\x20server.\n\x20Format\x20is\x20`projects/{project}/subscriptions/{su\ + b}`.\n\n\x0f\n\x05\x04\x1c\x02\0\x04\x12\x06\xe9\x05\x02\xe4\x05\x1e\n\r\ + \n\x05\x04\x1c\x02\0\x05\x12\x04\xe9\x05\x02\x08\n\r\n\x05\x04\x1c\x02\0\ + \x01\x12\x04\xe9\x05\t\x15\n\r\n\x05\x04\x1c\x02\0\x03\x12\x04\xe9\x05\ + \x18\x19\n\x85\x03\n\x04\x04\x1c\x02\x01\x12\x04\xf0\x05\x02\x1e\x1a\xf6\ + \x02\x20List\x20of\x20acknowledgement\x20IDs\x20for\x20acknowledging\x20\ + previously\x20received\x20messages\n\x20(received\x20on\x20this\x20strea\ + m\x20or\x20a\x20different\x20stream).\x20If\x20an\x20ack\x20ID\x20has\ + \x20expired,\n\x20the\x20corresponding\x20message\x20may\x20be\x20redeli\ + vered\x20later.\x20Acknowledging\x20a\x20message\n\x20more\x20than\x20on\ + ce\x20will\x20not\x20result\x20in\x20an\x20error.\x20If\x20the\x20acknow\ + ledgement\x20ID\x20is\n\x20malformed,\x20the\x20stream\x20will\x20be\x20\ + aborted\x20with\x20status\x20`INVALID_ARGUMENT`.\n\n\r\n\x05\x04\x1c\x02\ + \x01\x04\x12\x04\xf0\x05\x02\n\n\r\n\x05\x04\x1c\x02\x01\x05\x12\x04\xf0\ + \x05\x0b\x11\n\r\n\x05\x04\x1c\x02\x01\x01\x12\x04\xf0\x05\x12\x19\n\r\n\ + \x05\x04\x1c\x02\x01\x03\x12\x04\xf0\x05\x1c\x1d\n\x89\x06\n\x04\x04\x1c\ + \x02\x02\x12\x04\xfd\x05\x02-\x1a\xfa\x05\x20The\x20list\x20of\x20new\ + \x20ack\x20deadlines\x20for\x20the\x20IDs\x20listed\x20in\n\x20`modify_d\ + eadline_ack_ids`.\x20The\x20size\x20of\x20this\x20list\x20must\x20be\x20\ + the\x20same\x20as\x20the\n\x20size\x20of\x20`modify_deadline_ack_ids`.\ + \x20If\x20it\x20differs\x20the\x20stream\x20will\x20be\x20aborted\n\x20w\ + ith\x20`INVALID_ARGUMENT`.\x20Each\x20element\x20in\x20this\x20list\x20i\ + s\x20applied\x20to\x20the\n\x20element\x20in\x20the\x20same\x20position\ + \x20in\x20`modify_deadline_ack_ids`.\x20The\x20new\x20ack\n\x20deadline\ + \x20is\x20with\x20respect\x20to\x20the\x20time\x20this\x20request\x20was\ + \x20sent\x20to\x20the\x20Pub/Sub\n\x20system.\x20Must\x20be\x20>=\x200.\ + \x20For\x20example,\x20if\x20the\x20value\x20is\x2010,\x20the\x20new\x20\ + ack\x20deadline\n\x20will\x20expire\x2010\x20seconds\x20after\x20this\ + \x20request\x20is\x20received.\x20If\x20the\x20value\x20is\x200,\n\x20th\ + e\x20message\x20is\x20immediately\x20made\x20available\x20for\x20another\ + \x20streaming\x20or\n\x20non-streaming\x20pull\x20request.\x20If\x20the\ + \x20value\x20is\x20<\x200\x20(an\x20error),\x20the\x20stream\x20will\n\ + \x20be\x20aborted\x20with\x20status\x20`INVALID_ARGUMENT`.\n\n\r\n\x05\ + \x04\x1c\x02\x02\x04\x12\x04\xfd\x05\x02\n\n\r\n\x05\x04\x1c\x02\x02\x05\ + \x12\x04\xfd\x05\x0b\x10\n\r\n\x05\x04\x1c\x02\x02\x01\x12\x04\xfd\x05\ + \x11(\n\r\n\x05\x04\x1c\x02\x02\x03\x12\x04\xfd\x05+,\n\xc8\x02\n\x04\ + \x04\x1c\x02\x03\x12\x04\x84\x06\x02.\x1a\xb9\x02\x20List\x20of\x20ackno\ + wledgement\x20IDs\x20whose\x20deadline\x20will\x20be\x20modified\x20base\ + d\x20on\x20the\n\x20corresponding\x20element\x20in\x20`modify_deadline_s\ + econds`.\x20This\x20field\x20can\x20be\x20used\n\x20to\x20indicate\x20th\ + at\x20more\x20time\x20is\x20needed\x20to\x20process\x20a\x20message\x20b\ + y\x20the\n\x20subscriber,\x20or\x20to\x20make\x20the\x20message\x20avail\ + able\x20for\x20redelivery\x20if\x20the\n\x20processing\x20was\x20interru\ + pted.\n\n\r\n\x05\x04\x1c\x02\x03\x04\x12\x04\x84\x06\x02\n\n\r\n\x05\ + \x04\x1c\x02\x03\x05\x12\x04\x84\x06\x0b\x11\n\r\n\x05\x04\x1c\x02\x03\ + \x01\x12\x04\x84\x06\x12)\n\r\n\x05\x04\x1c\x02\x03\x03\x12\x04\x84\x06,\ + -\n\xb4\x02\n\x04\x04\x1c\x02\x04\x12\x04\x8a\x06\x02(\x1a\xa5\x02\x20Th\ + e\x20ack\x20deadline\x20to\x20use\x20for\x20the\x20stream.\x20This\x20mu\ + st\x20be\x20provided\x20in\x20the\n\x20first\x20request\x20on\x20the\x20\ + stream,\x20but\x20it\x20can\x20also\x20be\x20updated\x20on\x20subsequent\ + \n\x20requests\x20from\x20client\x20to\x20server.\x20The\x20minimum\x20d\ + eadline\x20you\x20can\x20specify\x20is\x2010\n\x20seconds.\x20The\x20max\ + imum\x20deadline\x20you\x20can\x20specify\x20is\x20600\x20seconds\x20(10\ + \x20minutes).\n\n\x0f\n\x05\x04\x1c\x02\x04\x04\x12\x06\x8a\x06\x02\x84\ + \x06.\n\r\n\x05\x04\x1c\x02\x04\x05\x12\x04\x8a\x06\x02\x07\n\r\n\x05\ + \x04\x1c\x02\x04\x01\x12\x04\x8a\x06\x08#\n\r\n\x05\x04\x1c\x02\x04\x03\ + \x12\x04\x8a\x06&'\n\x81\x01\n\x02\x04\x1d\x12\x06\x8f\x06\0\x92\x06\x01\ + \x1as\x20Response\x20for\x20the\x20`StreamingPull`\x20method.\x20This\ + \x20response\x20is\x20used\x20to\x20stream\n\x20messages\x20from\x20the\ + \x20server\x20to\x20the\x20client.\n\n\x0b\n\x03\x04\x1d\x01\x12\x04\x8f\ + \x06\x08\x1d\nB\n\x04\x04\x1d\x02\0\x12\x04\x91\x06\x021\x1a4\x20Receive\ + d\x20Pub/Sub\x20messages.\x20This\x20will\x20not\x20be\x20empty.\n\n\r\n\ + \x05\x04\x1d\x02\0\x04\x12\x04\x91\x06\x02\n\n\r\n\x05\x04\x1d\x02\0\x06\ + \x12\x04\x91\x06\x0b\x1a\n\r\n\x05\x04\x1d\x02\0\x01\x12\x04\x91\x06\x1b\ + ,\n\r\n\x05\x04\x1d\x02\0\x03\x12\x04\x91\x06/0\n\x93\x02\n\x02\x04\x1e\ + \x12\x06\x98\x06\0\xae\x06\x01\x1a\x84\x02\x20Request\x20for\x20the\x20`\ + CreateSnapshot`\x20method.

\n\x20ALPHA:\x20This\x20feature\ + \x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\ + \x20be\x20changed\x20in\n\x20backward-incompatible\x20ways\x20and\x20is\ + \x20not\x20recommended\x20for\x20production\x20use.\n\x20It\x20is\x20not\ + \x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\ + \n\x03\x04\x1e\x01\x12\x04\x98\x06\x08\x1d\n\x89\x03\n\x04\x04\x1e\x02\0\ + \x12\x04\x9f\x06\x02\x12\x1a\xfa\x02\x20Optional\x20user-provided\x20nam\ + e\x20for\x20this\x20snapshot.\n\x20If\x20the\x20name\x20is\x20not\x20pro\ + vided\x20in\x20the\x20request,\x20the\x20server\x20will\x20assign\x20a\ + \x20random\n\x20name\x20for\x20this\x20snapshot\x20on\x20the\x20same\x20\ + project\x20as\x20the\x20subscription.\n\x20Note\x20that\x20for\x20REST\ + \x20API\x20requests,\x20you\x20must\x20specify\x20a\x20name.\x20\x20See\ + \x20the\n\x20resource\ + \x20name\x20rules.\n\x20Format\x20is\x20`projects/{project}/snapshot\ + s/{snap}`.\n\n\x0f\n\x05\x04\x1e\x02\0\x04\x12\x06\x9f\x06\x02\x98\x06\ + \x1f\n\r\n\x05\x04\x1e\x02\0\x05\x12\x04\x9f\x06\x02\x08\n\r\n\x05\x04\ + \x1e\x02\0\x01\x12\x04\x9f\x06\t\r\n\r\n\x05\x04\x1e\x02\0\x03\x12\x04\ + \x9f\x06\x10\x11\n\xad\x04\n\x04\x04\x1e\x02\x01\x12\x04\xaa\x06\x02\x1a\ + \x1a\x9e\x04\x20The\x20subscription\x20whose\x20backlog\x20the\x20snapsh\ + ot\x20retains.\n\x20Specifically,\x20the\x20created\x20snapshot\x20is\ + \x20guaranteed\x20to\x20retain:\n\x20\x20(a)\x20The\x20existing\x20backl\ + og\x20on\x20the\x20subscription.\x20More\x20precisely,\x20this\x20is\n\ + \x20\x20\x20\x20\x20\x20defined\x20as\x20the\x20messages\x20in\x20the\ + \x20subscription's\x20backlog\x20that\x20are\n\x20\x20\x20\x20\x20\x20un\ + acknowledged\x20upon\x20the\x20successful\x20completion\x20of\x20the\n\ + \x20\x20\x20\x20\x20\x20`CreateSnapshot`\x20request;\x20as\x20well\x20as\ + :\n\x20\x20(b)\x20Any\x20messages\x20published\x20to\x20the\x20subscript\ + ion's\x20topic\x20following\x20the\n\x20\x20\x20\x20\x20\x20successful\ + \x20completion\x20of\x20the\x20CreateSnapshot\x20request.\n\x20Format\ + \x20is\x20`projects/{project}/subscriptions/{sub}`.\n\n\x0f\n\x05\x04\ + \x1e\x02\x01\x04\x12\x06\xaa\x06\x02\x9f\x06\x12\n\r\n\x05\x04\x1e\x02\ + \x01\x05\x12\x04\xaa\x06\x02\x08\n\r\n\x05\x04\x1e\x02\x01\x01\x12\x04\ + \xaa\x06\t\x15\n\r\n\x05\x04\x1e\x02\x01\x03\x12\x04\xaa\x06\x18\x19\nT\ + \n\x04\x04\x1e\x02\x02\x12\x04\xad\x06\x02!\x1aF\x20See\x20\x20Creating\x20and\x20managing\x20labels.\n\n\ + \x0f\n\x05\x04\x1e\x02\x02\x04\x12\x06\xad\x06\x02\xaa\x06\x1a\n\r\n\x05\ + \x04\x1e\x02\x02\x06\x12\x04\xad\x06\x02\x15\n\r\n\x05\x04\x1e\x02\x02\ + \x01\x12\x04\xad\x06\x16\x1c\n\r\n\x05\x04\x1e\x02\x02\x03\x12\x04\xad\ + \x06\x1f\x20\n\x91\x02\n\x02\x04\x1f\x12\x06\xb4\x06\0\xbb\x06\x01\x1a\ + \x82\x02\x20Request\x20for\x20the\x20UpdateSnapshot\x20method.

\n\ + \x20ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\ + \x20release.\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backwar\ + d-incompatible\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20prod\ + uction\n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\ + \x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x1f\x01\x12\x04\xb4\x06\x08\ + \x1d\n,\n\x04\x04\x1f\x02\0\x12\x04\xb6\x06\x02\x18\x1a\x1e\x20The\x20up\ + dated\x20snapshot\x20object.\n\n\x0f\n\x05\x04\x1f\x02\0\x04\x12\x06\xb6\ + \x06\x02\xb4\x06\x1f\n\r\n\x05\x04\x1f\x02\0\x06\x12\x04\xb6\x06\x02\n\n\ + \r\n\x05\x04\x1f\x02\0\x01\x12\x04\xb6\x06\x0b\x13\n\r\n\x05\x04\x1f\x02\ + \0\x03\x12\x04\xb6\x06\x16\x17\nl\n\x04\x04\x1f\x02\x01\x12\x04\xba\x06\ + \x02,\x1a^\x20Indicates\x20which\x20fields\x20in\x20the\x20provided\x20s\ + napshot\x20to\x20update.\n\x20Must\x20be\x20specified\x20and\x20non-empt\ + y.\n\n\x0f\n\x05\x04\x1f\x02\x01\x04\x12\x06\xba\x06\x02\xb6\x06\x18\n\r\ + \n\x05\x04\x1f\x02\x01\x06\x12\x04\xba\x06\x02\x1b\n\r\n\x05\x04\x1f\x02\ + \x01\x01\x12\x04\xba\x06\x1c'\n\r\n\x05\x04\x1f\x02\x01\x03\x12\x04\xba\ + \x06*+\n\xff\x01\n\x02\x04\x20\x12\x06\xc1\x06\0\xd6\x06\x01\x1a\xf0\x01\ + \x20A\x20snapshot\x20resource.

\n\x20ALPHA:\x20This\x20fea\ + ture\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20mi\ + ght\x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20\ + is\x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20is\x20n\ + ot\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\ + \x0b\n\x03\x04\x20\x01\x12\x04\xc1\x06\x08\x10\n)\n\x04\x04\x20\x02\0\ + \x12\x04\xc3\x06\x02\x12\x1a\x1b\x20The\x20name\x20of\x20the\x20snapshot\ + .\n\n\x0f\n\x05\x04\x20\x02\0\x04\x12\x06\xc3\x06\x02\xc1\x06\x12\n\r\n\ + \x05\x04\x20\x02\0\x05\x12\x04\xc3\x06\x02\x08\n\r\n\x05\x04\x20\x02\0\ + \x01\x12\x04\xc3\x06\t\r\n\r\n\x05\x04\x20\x02\0\x03\x12\x04\xc3\x06\x10\ + \x11\nU\n\x04\x04\x20\x02\x01\x12\x04\xc6\x06\x02\x13\x1aG\x20The\x20nam\ + e\x20of\x20the\x20topic\x20from\x20which\x20this\x20snapshot\x20is\x20re\ + taining\x20messages.\n\n\x0f\n\x05\x04\x20\x02\x01\x04\x12\x06\xc6\x06\ + \x02\xc3\x06\x12\n\r\n\x05\x04\x20\x02\x01\x05\x12\x04\xc6\x06\x02\x08\n\ + \r\n\x05\x04\x20\x02\x01\x01\x12\x04\xc6\x06\t\x0e\n\r\n\x05\x04\x20\x02\ + \x01\x03\x12\x04\xc6\x06\x11\x12\n\xd4\x05\n\x04\x04\x20\x02\x02\x12\x04\ + \xd2\x06\x02,\x1a\xc5\x05\x20The\x20snapshot\x20is\x20guaranteed\x20to\ + \x20exist\x20up\x20until\x20this\x20time.\n\x20A\x20newly-created\x20sna\ + pshot\x20expires\x20no\x20later\x20than\x207\x20days\x20from\x20the\x20t\ + ime\x20of\x20its\n\x20creation.\x20Its\x20exact\x20lifetime\x20is\x20det\ + ermined\x20at\x20creation\x20by\x20the\x20existing\n\x20backlog\x20in\ + \x20the\x20source\x20subscription.\x20Specifically,\x20the\x20lifetime\ + \x20of\x20the\n\x20snapshot\x20is\x20`7\x20days\x20-\x20(age\x20of\x20ol\ + dest\x20unacked\x20message\x20in\x20the\x20subscription)`.\n\x20For\x20e\ + xample,\x20consider\x20a\x20subscription\x20whose\x20oldest\x20unacked\ + \x20message\x20is\x203\x20days\n\x20old.\x20If\x20a\x20snapshot\x20is\ + \x20created\x20from\x20this\x20subscription,\x20the\x20snapshot\x20--\ + \x20which\n\x20will\x20always\x20capture\x20this\x203-day-old\x20backlog\ + \x20as\x20long\x20as\x20the\x20snapshot\n\x20exists\x20--\x20will\x20exp\ + ire\x20in\x204\x20days.\x20The\x20service\x20will\x20refuse\x20to\x20cre\ + ate\x20a\n\x20snapshot\x20that\x20would\x20expire\x20in\x20less\x20than\ + \x201\x20hour\x20after\x20creation.\n\n\x0f\n\x05\x04\x20\x02\x02\x04\ + \x12\x06\xd2\x06\x02\xc6\x06\x13\n\r\n\x05\x04\x20\x02\x02\x06\x12\x04\ + \xd2\x06\x02\x1b\n\r\n\x05\x04\x20\x02\x02\x01\x12\x04\xd2\x06\x1c'\n\r\ + \n\x05\x04\x20\x02\x02\x03\x12\x04\xd2\x06*+\nT\n\x04\x04\x20\x02\x03\ + \x12\x04\xd5\x06\x02!\x1aF\x20See\x20\ + \x20Creating\x20and\x20managing\x20labels.\n\n\x0f\n\x05\x04\x20\x02\ + \x03\x04\x12\x06\xd5\x06\x02\xd2\x06,\n\r\n\x05\x04\x20\x02\x03\x06\x12\ + \x04\xd5\x06\x02\x15\n\r\n\x05\x04\x20\x02\x03\x01\x12\x04\xd5\x06\x16\ + \x1c\n\r\n\x05\x04\x20\x02\x03\x03\x12\x04\xd5\x06\x1f\x20\n\x8e\x02\n\ + \x02\x04!\x12\x06\xdc\x06\0\xe0\x06\x01\x1a\xff\x01\x20Request\x20for\ + \x20the\x20GetSnapshot\x20method.

\n\x20ALPHA:\x20This\x20\ + feature\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\ + \x20might\x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20a\ + nd\x20is\x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20i\ + s\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\ + \n\n\x0b\n\x03\x04!\x01\x12\x04\xdc\x06\x08\x1a\nb\n\x04\x04!\x02\0\x12\ + \x04\xdf\x06\x02\x16\x1aT\x20The\x20name\x20of\x20the\x20snapshot\x20to\ + \x20get.\n\x20Format\x20is\x20`projects/{project}/snapshots/{snap}`.\n\n\ + \x0f\n\x05\x04!\x02\0\x04\x12\x06\xdf\x06\x02\xdc\x06\x1c\n\r\n\x05\x04!\ + \x02\0\x05\x12\x04\xdf\x06\x02\x08\n\r\n\x05\x04!\x02\0\x01\x12\x04\xdf\ + \x06\t\x11\n\r\n\x05\x04!\x02\0\x03\x12\x04\xdf\x06\x14\x15\n\x92\x02\n\ + \x02\x04\"\x12\x06\xe6\x06\0\xf2\x06\x01\x1a\x83\x02\x20Request\x20for\ + \x20the\x20`ListSnapshots`\x20method.

\n\x20ALPHA:\x20This\ + \x20feature\x20is\x20part\x20of\x20an\x20alpha\x20release.\x20This\x20AP\ + I\x20might\x20be\n\x20changed\x20in\x20backward-incompatible\x20ways\x20\ + and\x20is\x20not\x20recommended\x20for\x20production\n\x20use.\x20It\x20\ + is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\ + \n\n\x0b\n\x03\x04\"\x01\x12\x04\xe6\x06\x08\x1c\ng\n\x04\x04\"\x02\0\ + \x12\x04\xe9\x06\x02\x15\x1aY\x20The\x20name\x20of\x20the\x20project\x20\ + in\x20which\x20to\x20list\x20snapshots.\n\x20Format\x20is\x20`projects/{\ + project-id}`.\n\n\x0f\n\x05\x04\"\x02\0\x04\x12\x06\xe9\x06\x02\xe6\x06\ + \x1e\n\r\n\x05\x04\"\x02\0\x05\x12\x04\xe9\x06\x02\x08\n\r\n\x05\x04\"\ + \x02\0\x01\x12\x04\xe9\x06\t\x10\n\r\n\x05\x04\"\x02\0\x03\x12\x04\xe9\ + \x06\x13\x14\n6\n\x04\x04\"\x02\x01\x12\x04\xec\x06\x02\x16\x1a(\x20Maxi\ + mum\x20number\x20of\x20snapshots\x20to\x20return.\n\n\x0f\n\x05\x04\"\ + \x02\x01\x04\x12\x06\xec\x06\x02\xe9\x06\x15\n\r\n\x05\x04\"\x02\x01\x05\ + \x12\x04\xec\x06\x02\x07\n\r\n\x05\x04\"\x02\x01\x01\x12\x04\xec\x06\x08\ + \x11\n\r\n\x05\x04\"\x02\x01\x03\x12\x04\xec\x06\x14\x15\n\xca\x01\n\x04\ + \x04\"\x02\x02\x12\x04\xf1\x06\x02\x18\x1a\xbb\x01\x20The\x20value\x20re\ + turned\x20by\x20the\x20last\x20`ListSnapshotsResponse`;\x20indicates\x20\ + that\x20this\n\x20is\x20a\x20continuation\x20of\x20a\x20prior\x20`ListSn\ + apshots`\x20call,\x20and\x20that\x20the\x20system\n\x20should\x20return\ + \x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\x05\x04\"\x02\x02\x04\ + \x12\x06\xf1\x06\x02\xec\x06\x16\n\r\n\x05\x04\"\x02\x02\x05\x12\x04\xf1\ + \x06\x02\x08\n\r\n\x05\x04\"\x02\x02\x01\x12\x04\xf1\x06\t\x13\n\r\n\x05\ + \x04\"\x02\x02\x03\x12\x04\xf1\x06\x16\x17\n\x93\x02\n\x02\x04#\x12\x06\ + \xf8\x06\0\xff\x06\x01\x1a\x84\x02\x20Response\x20for\x20the\x20`ListSna\ + pshots`\x20method.

\n\x20ALPHA:\x20This\x20feature\x20is\ + \x20part\x20of\x20an\x20alpha\x20release.\x20This\x20API\x20might\x20be\ + \n\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\ + \x20recommended\x20for\x20production\n\x20use.\x20It\x20is\x20not\x20sub\ + ject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\ + \x04#\x01\x12\x04\xf8\x06\x08\x1d\n(\n\x04\x04#\x02\0\x12\x04\xfa\x06\ + \x02\"\x1a\x1a\x20The\x20resulting\x20snapshots.\n\n\r\n\x05\x04#\x02\0\ + \x04\x12\x04\xfa\x06\x02\n\n\r\n\x05\x04#\x02\0\x06\x12\x04\xfa\x06\x0b\ + \x13\n\r\n\x05\x04#\x02\0\x01\x12\x04\xfa\x06\x14\x1d\n\r\n\x05\x04#\x02\ + \0\x03\x12\x04\xfa\x06\x20!\n\x9e\x01\n\x04\x04#\x02\x01\x12\x04\xfe\x06\ + \x02\x1d\x1a\x8f\x01\x20If\x20not\x20empty,\x20indicates\x20that\x20ther\ + e\x20may\x20be\x20more\x20snapshot\x20that\x20match\x20the\n\x20request;\ + \x20this\x20value\x20should\x20be\x20passed\x20in\x20a\x20new\x20`ListSn\ + apshotsRequest`.\n\n\x0f\n\x05\x04#\x02\x01\x04\x12\x06\xfe\x06\x02\xfa\ + \x06\"\n\r\n\x05\x04#\x02\x01\x05\x12\x04\xfe\x06\x02\x08\n\r\n\x05\x04#\ + \x02\x01\x01\x12\x04\xfe\x06\t\x18\n\r\n\x05\x04#\x02\x01\x03\x12\x04\ + \xfe\x06\x1b\x1c\n\x93\x02\n\x02\x04$\x12\x06\x85\x07\0\x89\x07\x01\x1a\ + \x84\x02\x20Request\x20for\x20the\x20`DeleteSnapshot`\x20method.

\ + \n\x20ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alph\ + a\x20release.\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backwa\ + rd-incompatible\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20pro\ + duction\n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20o\ + r\x20deprecation\x20policy.\n\n\x0b\n\x03\x04$\x01\x12\x04\x85\x07\x08\ + \x1d\ne\n\x04\x04$\x02\0\x12\x04\x88\x07\x02\x16\x1aW\x20The\x20name\x20\ + of\x20the\x20snapshot\x20to\x20delete.\n\x20Format\x20is\x20`projects/{p\ + roject}/snapshots/{snap}`.\n\n\x0f\n\x05\x04$\x02\0\x04\x12\x06\x88\x07\ + \x02\x85\x07\x1f\n\r\n\x05\x04$\x02\0\x05\x12\x04\x88\x07\x02\x08\n\r\n\ + \x05\x04$\x02\0\x01\x12\x04\x88\x07\t\x11\n\r\n\x05\x04$\x02\0\x03\x12\ + \x04\x88\x07\x14\x15\n\x89\x02\n\x02\x04%\x12\x06\x8f\x07\0\xa6\x07\x01\ + \x1a\xfa\x01\x20Request\x20for\x20the\x20`Seek`\x20method.

\n\x20\ + ALPHA:\x20This\x20feature\x20is\x20part\x20of\x20an\x20alpha\x20r\ + elease.\x20This\x20API\x20might\x20be\n\x20changed\x20in\x20backward-inc\ + ompatible\x20ways\x20and\x20is\x20not\x20recommended\x20for\x20productio\ + n\n\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20d\ + eprecation\x20policy.\n\n\x0b\n\x03\x04%\x01\x12\x04\x8f\x07\x08\x13\n+\ + \n\x04\x04%\x02\0\x12\x04\x91\x07\x02\x1a\x1a\x1d\x20The\x20subscription\ + \x20to\x20affect.\n\n\x0f\n\x05\x04%\x02\0\x04\x12\x06\x91\x07\x02\x8f\ + \x07\x15\n\r\n\x05\x04%\x02\0\x05\x12\x04\x91\x07\x02\x08\n\r\n\x05\x04%\ + \x02\0\x01\x12\x04\x91\x07\t\x15\n\r\n\x05\x04%\x02\0\x03\x12\x04\x91\ + \x07\x18\x19\n\x0e\n\x04\x04%\x08\0\x12\x06\x93\x07\x02\xa5\x07\x03\n\r\ + \n\x05\x04%\x08\0\x01\x12\x04\x93\x07\x08\x0e\n\xbe\x05\n\x04\x04%\x02\ + \x01\x12\x04\x9f\x07\x04'\x1a\xaf\x05\x20The\x20time\x20to\x20seek\x20to\ + .\n\x20Messages\x20retained\x20in\x20the\x20subscription\x20that\x20were\ + \x20published\x20before\x20this\n\x20time\x20are\x20marked\x20as\x20ackn\ + owledged,\x20and\x20messages\x20retained\x20in\x20the\n\x20subscription\ + \x20that\x20were\x20published\x20after\x20this\x20time\x20are\x20marked\ + \x20as\n\x20unacknowledged.\x20Note\x20that\x20this\x20operation\x20affe\ + cts\x20only\x20those\x20messages\n\x20retained\x20in\x20the\x20subscript\ + ion\x20(configured\x20by\x20the\x20combination\x20of\n\x20`message_reten\ + tion_duration`\x20and\x20`retain_acked_messages`).\x20For\x20example,\n\ + \x20if\x20`time`\x20corresponds\x20to\x20a\x20point\x20before\x20the\x20\ + message\x20retention\n\x20window\x20(or\x20to\x20a\x20point\x20before\ + \x20the\x20system's\x20notion\x20of\x20the\x20subscription\n\x20creation\ + \x20time),\x20only\x20retained\x20messages\x20will\x20be\x20marked\x20as\ + \x20unacknowledged,\n\x20and\x20already-expunged\x20messages\x20will\x20\ + not\x20be\x20restored.\n\n\r\n\x05\x04%\x02\x01\x06\x12\x04\x9f\x07\x04\ + \x1d\n\r\n\x05\x04%\x02\x01\x01\x12\x04\x9f\x07\x1e\"\n\r\n\x05\x04%\x02\ + \x01\x03\x12\x04\x9f\x07%&\n\xa8\x01\n\x04\x04%\x02\x02\x12\x04\xa4\x07\ + \x04\x18\x1a\x99\x01\x20The\x20snapshot\x20to\x20seek\x20to.\x20The\x20s\ + napshot's\x20topic\x20must\x20be\x20the\x20same\x20as\x20that\x20of\n\ + \x20the\x20provided\x20subscription.\n\x20Format\x20is\x20`projects/{pro\ + ject}/snapshots/{snap}`.\n\n\r\n\x05\x04%\x02\x02\x05\x12\x04\xa4\x07\ + \x04\n\n\r\n\x05\x04%\x02\x02\x01\x12\x04\xa4\x07\x0b\x13\n\r\n\x05\x04%\ + \x02\x02\x03\x12\x04\xa4\x07\x16\x17\nH\n\x02\x04&\x12\x06\xa9\x07\0\xab\ + \x07\x01\x1a:\x20Response\x20for\x20the\x20`Seek`\x20method\x20(this\x20\ + response\x20is\x20empty).\n\n\x0b\n\x03\x04&\x01\x12\x04\xa9\x07\x08\x14\ + b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub_grpc.rs new file mode 100644 index 00000000..821777c3 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1/pubsub_grpc.rs @@ -0,0 +1,731 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_PUBLISHER_CREATE_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/CreateTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_UPDATE_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/UpdateTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_PUBLISH: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/Publish", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_GET_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/GetTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_LIST_TOPICS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/ListTopics", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/ListTopicSubscriptions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_LIST_TOPIC_SNAPSHOTS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/ListTopicSnapshots", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_DELETE_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Publisher/DeleteTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct PublisherClient { + client: ::grpcio::Client, +} + +impl PublisherClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + PublisherClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_topic_opt(&self, req: &super::pubsub::Topic, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_CREATE_TOPIC, req, opt) + } + + pub fn create_topic(&self, req: &super::pubsub::Topic) -> ::grpcio::Result { + self.create_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_topic_async_opt(&self, req: &super::pubsub::Topic, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_CREATE_TOPIC, req, opt) + } + + pub fn create_topic_async(&self, req: &super::pubsub::Topic) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_topic_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_topic_opt(&self, req: &super::pubsub::UpdateTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_UPDATE_TOPIC, req, opt) + } + + pub fn update_topic(&self, req: &super::pubsub::UpdateTopicRequest) -> ::grpcio::Result { + self.update_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_topic_async_opt(&self, req: &super::pubsub::UpdateTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_UPDATE_TOPIC, req, opt) + } + + pub fn update_topic_async(&self, req: &super::pubsub::UpdateTopicRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_topic_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn publish_opt(&self, req: &super::pubsub::PublishRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_PUBLISH, req, opt) + } + + pub fn publish(&self, req: &super::pubsub::PublishRequest) -> ::grpcio::Result { + self.publish_opt(req, ::grpcio::CallOption::default()) + } + + pub fn publish_async_opt(&self, req: &super::pubsub::PublishRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_PUBLISH, req, opt) + } + + pub fn publish_async(&self, req: &super::pubsub::PublishRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.publish_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_topic_opt(&self, req: &super::pubsub::GetTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_GET_TOPIC, req, opt) + } + + pub fn get_topic(&self, req: &super::pubsub::GetTopicRequest) -> ::grpcio::Result { + self.get_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_topic_async_opt(&self, req: &super::pubsub::GetTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_GET_TOPIC, req, opt) + } + + pub fn get_topic_async(&self, req: &super::pubsub::GetTopicRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_topic_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topics_opt(&self, req: &super::pubsub::ListTopicsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_LIST_TOPICS, req, opt) + } + + pub fn list_topics(&self, req: &super::pubsub::ListTopicsRequest) -> ::grpcio::Result { + self.list_topics_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topics_async_opt(&self, req: &super::pubsub::ListTopicsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_LIST_TOPICS, req, opt) + } + + pub fn list_topics_async(&self, req: &super::pubsub::ListTopicsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_topics_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_subscriptions_opt(&self, req: &super::pubsub::ListTopicSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, req, opt) + } + + pub fn list_topic_subscriptions(&self, req: &super::pubsub::ListTopicSubscriptionsRequest) -> ::grpcio::Result { + self.list_topic_subscriptions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_subscriptions_async_opt(&self, req: &super::pubsub::ListTopicSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, req, opt) + } + + pub fn list_topic_subscriptions_async(&self, req: &super::pubsub::ListTopicSubscriptionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_topic_subscriptions_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_snapshots_opt(&self, req: &super::pubsub::ListTopicSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_LIST_TOPIC_SNAPSHOTS, req, opt) + } + + pub fn list_topic_snapshots(&self, req: &super::pubsub::ListTopicSnapshotsRequest) -> ::grpcio::Result { + self.list_topic_snapshots_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_snapshots_async_opt(&self, req: &super::pubsub::ListTopicSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_LIST_TOPIC_SNAPSHOTS, req, opt) + } + + pub fn list_topic_snapshots_async(&self, req: &super::pubsub::ListTopicSnapshotsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_topic_snapshots_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_topic_opt(&self, req: &super::pubsub::DeleteTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_DELETE_TOPIC, req, opt) + } + + pub fn delete_topic(&self, req: &super::pubsub::DeleteTopicRequest) -> ::grpcio::Result { + self.delete_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_topic_async_opt(&self, req: &super::pubsub::DeleteTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_DELETE_TOPIC, req, opt) + } + + pub fn delete_topic_async(&self, req: &super::pubsub::DeleteTopicRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_topic_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Publisher { + fn create_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::Topic, sink: ::grpcio::UnarySink); + fn update_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::UpdateTopicRequest, sink: ::grpcio::UnarySink); + fn publish(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::PublishRequest, sink: ::grpcio::UnarySink); + fn get_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::GetTopicRequest, sink: ::grpcio::UnarySink); + fn list_topics(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListTopicsRequest, sink: ::grpcio::UnarySink); + fn list_topic_subscriptions(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListTopicSubscriptionsRequest, sink: ::grpcio::UnarySink); + fn list_topic_snapshots(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListTopicSnapshotsRequest, sink: ::grpcio::UnarySink); + fn delete_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::DeleteTopicRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_publisher(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_CREATE_TOPIC, move |ctx, req, resp| { + instance.create_topic(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_UPDATE_TOPIC, move |ctx, req, resp| { + instance.update_topic(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_PUBLISH, move |ctx, req, resp| { + instance.publish(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_GET_TOPIC, move |ctx, req, resp| { + instance.get_topic(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_LIST_TOPICS, move |ctx, req, resp| { + instance.list_topics(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, move |ctx, req, resp| { + instance.list_topic_subscriptions(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_LIST_TOPIC_SNAPSHOTS, move |ctx, req, resp| { + instance.list_topic_snapshots(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_DELETE_TOPIC, move |ctx, req, resp| { + instance.delete_topic(ctx, req, resp) + }); + builder.build() +} + +const METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/CreateSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_GET_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/GetSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_UPDATE_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/UpdateSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/ListSubscriptions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/DeleteSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/ModifyAckDeadline", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_ACKNOWLEDGE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/Acknowledge", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_PULL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/Pull", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_STREAMING_PULL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Duplex, + name: "/google.pubsub.v1.Subscriber/StreamingPull", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/ModifyPushConfig", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_GET_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/GetSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_LIST_SNAPSHOTS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/ListSnapshots", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_CREATE_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/CreateSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_UPDATE_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/UpdateSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_DELETE_SNAPSHOT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/DeleteSnapshot", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_SEEK: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1.Subscriber/Seek", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct SubscriberClient { + client: ::grpcio::Client, +} + +impl SubscriberClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + SubscriberClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_subscription_opt(&self, req: &super::pubsub::Subscription, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, req, opt) + } + + pub fn create_subscription(&self, req: &super::pubsub::Subscription) -> ::grpcio::Result { + self.create_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_subscription_async_opt(&self, req: &super::pubsub::Subscription, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, req, opt) + } + + pub fn create_subscription_async(&self, req: &super::pubsub::Subscription) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_subscription_opt(&self, req: &super::pubsub::GetSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, req, opt) + } + + pub fn get_subscription(&self, req: &super::pubsub::GetSubscriptionRequest) -> ::grpcio::Result { + self.get_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_subscription_async_opt(&self, req: &super::pubsub::GetSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, req, opt) + } + + pub fn get_subscription_async(&self, req: &super::pubsub::GetSubscriptionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_subscription_opt(&self, req: &super::pubsub::UpdateSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_UPDATE_SUBSCRIPTION, req, opt) + } + + pub fn update_subscription(&self, req: &super::pubsub::UpdateSubscriptionRequest) -> ::grpcio::Result { + self.update_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_subscription_async_opt(&self, req: &super::pubsub::UpdateSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_UPDATE_SUBSCRIPTION, req, opt) + } + + pub fn update_subscription_async(&self, req: &super::pubsub::UpdateSubscriptionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_subscriptions_opt(&self, req: &super::pubsub::ListSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, req, opt) + } + + pub fn list_subscriptions(&self, req: &super::pubsub::ListSubscriptionsRequest) -> ::grpcio::Result { + self.list_subscriptions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_subscriptions_async_opt(&self, req: &super::pubsub::ListSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, req, opt) + } + + pub fn list_subscriptions_async(&self, req: &super::pubsub::ListSubscriptionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_subscriptions_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_subscription_opt(&self, req: &super::pubsub::DeleteSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, req, opt) + } + + pub fn delete_subscription(&self, req: &super::pubsub::DeleteSubscriptionRequest) -> ::grpcio::Result { + self.delete_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_subscription_async_opt(&self, req: &super::pubsub::DeleteSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, req, opt) + } + + pub fn delete_subscription_async(&self, req: &super::pubsub::DeleteSubscriptionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_ack_deadline_opt(&self, req: &super::pubsub::ModifyAckDeadlineRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, req, opt) + } + + pub fn modify_ack_deadline(&self, req: &super::pubsub::ModifyAckDeadlineRequest) -> ::grpcio::Result { + self.modify_ack_deadline_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_ack_deadline_async_opt(&self, req: &super::pubsub::ModifyAckDeadlineRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, req, opt) + } + + pub fn modify_ack_deadline_async(&self, req: &super::pubsub::ModifyAckDeadlineRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.modify_ack_deadline_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn acknowledge_opt(&self, req: &super::pubsub::AcknowledgeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_ACKNOWLEDGE, req, opt) + } + + pub fn acknowledge(&self, req: &super::pubsub::AcknowledgeRequest) -> ::grpcio::Result { + self.acknowledge_opt(req, ::grpcio::CallOption::default()) + } + + pub fn acknowledge_async_opt(&self, req: &super::pubsub::AcknowledgeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_ACKNOWLEDGE, req, opt) + } + + pub fn acknowledge_async(&self, req: &super::pubsub::AcknowledgeRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.acknowledge_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn pull_opt(&self, req: &super::pubsub::PullRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_PULL, req, opt) + } + + pub fn pull(&self, req: &super::pubsub::PullRequest) -> ::grpcio::Result { + self.pull_opt(req, ::grpcio::CallOption::default()) + } + + pub fn pull_async_opt(&self, req: &super::pubsub::PullRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_PULL, req, opt) + } + + pub fn pull_async(&self, req: &super::pubsub::PullRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.pull_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn streaming_pull_opt(&self, opt: ::grpcio::CallOption) -> ::grpcio::Result<(::grpcio::ClientDuplexSender, ::grpcio::ClientDuplexReceiver)> { + self.client.duplex_streaming(&METHOD_SUBSCRIBER_STREAMING_PULL, opt) + } + + pub fn streaming_pull(&self) -> ::grpcio::Result<(::grpcio::ClientDuplexSender, ::grpcio::ClientDuplexReceiver)> { + self.streaming_pull_opt(::grpcio::CallOption::default()) + } + + pub fn modify_push_config_opt(&self, req: &super::pubsub::ModifyPushConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, req, opt) + } + + pub fn modify_push_config(&self, req: &super::pubsub::ModifyPushConfigRequest) -> ::grpcio::Result { + self.modify_push_config_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_push_config_async_opt(&self, req: &super::pubsub::ModifyPushConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, req, opt) + } + + pub fn modify_push_config_async(&self, req: &super::pubsub::ModifyPushConfigRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.modify_push_config_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_snapshot_opt(&self, req: &super::pubsub::GetSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_GET_SNAPSHOT, req, opt) + } + + pub fn get_snapshot(&self, req: &super::pubsub::GetSnapshotRequest) -> ::grpcio::Result { + self.get_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_snapshot_async_opt(&self, req: &super::pubsub::GetSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_GET_SNAPSHOT, req, opt) + } + + pub fn get_snapshot_async(&self, req: &super::pubsub::GetSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_snapshots_opt(&self, req: &super::pubsub::ListSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_LIST_SNAPSHOTS, req, opt) + } + + pub fn list_snapshots(&self, req: &super::pubsub::ListSnapshotsRequest) -> ::grpcio::Result { + self.list_snapshots_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_snapshots_async_opt(&self, req: &super::pubsub::ListSnapshotsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_LIST_SNAPSHOTS, req, opt) + } + + pub fn list_snapshots_async(&self, req: &super::pubsub::ListSnapshotsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_snapshots_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_snapshot_opt(&self, req: &super::pubsub::CreateSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_CREATE_SNAPSHOT, req, opt) + } + + pub fn create_snapshot(&self, req: &super::pubsub::CreateSnapshotRequest) -> ::grpcio::Result { + self.create_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_snapshot_async_opt(&self, req: &super::pubsub::CreateSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_CREATE_SNAPSHOT, req, opt) + } + + pub fn create_snapshot_async(&self, req: &super::pubsub::CreateSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_snapshot_opt(&self, req: &super::pubsub::UpdateSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_UPDATE_SNAPSHOT, req, opt) + } + + pub fn update_snapshot(&self, req: &super::pubsub::UpdateSnapshotRequest) -> ::grpcio::Result { + self.update_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_snapshot_async_opt(&self, req: &super::pubsub::UpdateSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_UPDATE_SNAPSHOT, req, opt) + } + + pub fn update_snapshot_async(&self, req: &super::pubsub::UpdateSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_snapshot_opt(&self, req: &super::pubsub::DeleteSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_DELETE_SNAPSHOT, req, opt) + } + + pub fn delete_snapshot(&self, req: &super::pubsub::DeleteSnapshotRequest) -> ::grpcio::Result { + self.delete_snapshot_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_snapshot_async_opt(&self, req: &super::pubsub::DeleteSnapshotRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_DELETE_SNAPSHOT, req, opt) + } + + pub fn delete_snapshot_async(&self, req: &super::pubsub::DeleteSnapshotRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_snapshot_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn seek_opt(&self, req: &super::pubsub::SeekRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_SEEK, req, opt) + } + + pub fn seek(&self, req: &super::pubsub::SeekRequest) -> ::grpcio::Result { + self.seek_opt(req, ::grpcio::CallOption::default()) + } + + pub fn seek_async_opt(&self, req: &super::pubsub::SeekRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_SEEK, req, opt) + } + + pub fn seek_async(&self, req: &super::pubsub::SeekRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.seek_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Subscriber { + fn create_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::Subscription, sink: ::grpcio::UnarySink); + fn get_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::GetSubscriptionRequest, sink: ::grpcio::UnarySink); + fn update_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::UpdateSubscriptionRequest, sink: ::grpcio::UnarySink); + fn list_subscriptions(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListSubscriptionsRequest, sink: ::grpcio::UnarySink); + fn delete_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::DeleteSubscriptionRequest, sink: ::grpcio::UnarySink); + fn modify_ack_deadline(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ModifyAckDeadlineRequest, sink: ::grpcio::UnarySink); + fn acknowledge(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::AcknowledgeRequest, sink: ::grpcio::UnarySink); + fn pull(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::PullRequest, sink: ::grpcio::UnarySink); + fn streaming_pull(&mut self, ctx: ::grpcio::RpcContext, stream: ::grpcio::RequestStream, sink: ::grpcio::DuplexSink); + fn modify_push_config(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ModifyPushConfigRequest, sink: ::grpcio::UnarySink); + fn get_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::GetSnapshotRequest, sink: ::grpcio::UnarySink); + fn list_snapshots(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListSnapshotsRequest, sink: ::grpcio::UnarySink); + fn create_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::CreateSnapshotRequest, sink: ::grpcio::UnarySink); + fn update_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::UpdateSnapshotRequest, sink: ::grpcio::UnarySink); + fn delete_snapshot(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::DeleteSnapshotRequest, sink: ::grpcio::UnarySink); + fn seek(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::SeekRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_subscriber(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, move |ctx, req, resp| { + instance.create_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, move |ctx, req, resp| { + instance.get_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_UPDATE_SUBSCRIPTION, move |ctx, req, resp| { + instance.update_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, move |ctx, req, resp| { + instance.list_subscriptions(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, move |ctx, req, resp| { + instance.delete_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, move |ctx, req, resp| { + instance.modify_ack_deadline(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_ACKNOWLEDGE, move |ctx, req, resp| { + instance.acknowledge(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_PULL, move |ctx, req, resp| { + instance.pull(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_duplex_streaming_handler(&METHOD_SUBSCRIBER_STREAMING_PULL, move |ctx, req, resp| { + instance.streaming_pull(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, move |ctx, req, resp| { + instance.modify_push_config(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_GET_SNAPSHOT, move |ctx, req, resp| { + instance.get_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_LIST_SNAPSHOTS, move |ctx, req, resp| { + instance.list_snapshots(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_CREATE_SNAPSHOT, move |ctx, req, resp| { + instance.create_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_UPDATE_SNAPSHOT, move |ctx, req, resp| { + instance.update_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_DELETE_SNAPSHOT, move |ctx, req, resp| { + instance.delete_snapshot(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_SEEK, move |ctx, req, resp| { + instance.seek(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/mod.rs new file mode 100644 index 00000000..a7f02e63 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/mod.rs @@ -0,0 +1,4 @@ +pub mod pubsub; +pub mod pubsub_grpc; + +pub(crate) use crate::empty; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub.rs new file mode 100644 index 00000000..26c8ca45 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub.rs @@ -0,0 +1,5284 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/pubsub/v1beta2/pubsub.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Topic { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Topic { + fn default() -> &'a Topic { + ::default_instance() + } +} + +impl Topic { + pub fn new() -> Topic { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Topic { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Topic { + Topic::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Topic| { &m.name }, + |m: &mut Topic| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Topic", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Topic { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Topic, + }; + unsafe { + instance.get(Topic::new) + } + } +} + +impl ::protobuf::Clear for Topic { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Topic { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Topic { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PubsubMessage { + // message fields + pub data: ::std::vec::Vec, + pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + pub message_id: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PubsubMessage { + fn default() -> &'a PubsubMessage { + ::default_instance() + } +} + +impl PubsubMessage { + pub fn new() -> PubsubMessage { + ::std::default::Default::default() + } + + // bytes data = 1; + + + pub fn get_data(&self) -> &[u8] { + &self.data + } + pub fn clear_data(&mut self) { + self.data.clear(); + } + + // Param is passed by value, moved + pub fn set_data(&mut self, v: ::std::vec::Vec) { + self.data = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_data(&mut self) -> &mut ::std::vec::Vec { + &mut self.data + } + + // Take field + pub fn take_data(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.data, ::std::vec::Vec::new()) + } + + // repeated .google.pubsub.v1beta2.PubsubMessage.AttributesEntry attributes = 2; + + + pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.attributes + } + pub fn clear_attributes(&mut self) { + self.attributes.clear(); + } + + // Param is passed by value, moved + pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.attributes = v; + } + + // Mutable pointer to the field. + pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.attributes + } + + // Take field + pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new()) + } + + // string message_id = 3; + + + pub fn get_message_id(&self) -> &str { + &self.message_id + } + pub fn clear_message_id(&mut self) { + self.message_id.clear(); + } + + // Param is passed by value, moved + pub fn set_message_id(&mut self, v: ::std::string::String) { + self.message_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message_id(&mut self) -> &mut ::std::string::String { + &mut self.message_id + } + + // Take field + pub fn take_message_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.message_id, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for PubsubMessage { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.data)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message_id)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.data.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.data); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes); + if !self.message_id.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.message_id); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.data.is_empty() { + os.write_bytes(1, &self.data)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, os)?; + if !self.message_id.is_empty() { + os.write_string(3, &self.message_id)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PubsubMessage { + PubsubMessage::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "data", + |m: &PubsubMessage| { &m.data }, + |m: &mut PubsubMessage| { &mut m.data }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "attributes", + |m: &PubsubMessage| { &m.attributes }, + |m: &mut PubsubMessage| { &mut m.attributes }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message_id", + |m: &PubsubMessage| { &m.message_id }, + |m: &mut PubsubMessage| { &mut m.message_id }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PubsubMessage", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PubsubMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PubsubMessage, + }; + unsafe { + instance.get(PubsubMessage::new) + } + } +} + +impl ::protobuf::Clear for PubsubMessage { + fn clear(&mut self) { + self.data.clear(); + self.attributes.clear(); + self.message_id.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PubsubMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PubsubMessage { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetTopicRequest { + // message fields + pub topic: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetTopicRequest { + fn default() -> &'a GetTopicRequest { + ::default_instance() + } +} + +impl GetTopicRequest { + pub fn new() -> GetTopicRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetTopicRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetTopicRequest { + GetTopicRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &GetTopicRequest| { &m.topic }, + |m: &mut GetTopicRequest| { &mut m.topic }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetTopicRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetTopicRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetTopicRequest, + }; + unsafe { + instance.get(GetTopicRequest::new) + } + } +} + +impl ::protobuf::Clear for GetTopicRequest { + fn clear(&mut self) { + self.topic.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetTopicRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetTopicRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PublishRequest { + // message fields + pub topic: ::std::string::String, + pub messages: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PublishRequest { + fn default() -> &'a PublishRequest { + ::default_instance() + } +} + +impl PublishRequest { + pub fn new() -> PublishRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1beta2.PubsubMessage messages = 2; + + + pub fn get_messages(&self) -> &[PubsubMessage] { + &self.messages + } + pub fn clear_messages(&mut self) { + self.messages.clear(); + } + + // Param is passed by value, moved + pub fn set_messages(&mut self, v: ::protobuf::RepeatedField) { + self.messages = v; + } + + // Mutable pointer to the field. + pub fn mut_messages(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.messages + } + + // Take field + pub fn take_messages(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.messages, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PublishRequest { + fn is_initialized(&self) -> bool { + for v in &self.messages { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.messages)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + for value in &self.messages { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + for v in &self.messages { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PublishRequest { + PublishRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &PublishRequest| { &m.topic }, + |m: &mut PublishRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "messages", + |m: &PublishRequest| { &m.messages }, + |m: &mut PublishRequest| { &mut m.messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PublishRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PublishRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PublishRequest, + }; + unsafe { + instance.get(PublishRequest::new) + } + } +} + +impl ::protobuf::Clear for PublishRequest { + fn clear(&mut self) { + self.topic.clear(); + self.messages.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PublishRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PublishRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PublishResponse { + // message fields + pub message_ids: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PublishResponse { + fn default() -> &'a PublishResponse { + ::default_instance() + } +} + +impl PublishResponse { + pub fn new() -> PublishResponse { + ::std::default::Default::default() + } + + // repeated string message_ids = 1; + + + pub fn get_message_ids(&self) -> &[::std::string::String] { + &self.message_ids + } + pub fn clear_message_ids(&mut self) { + self.message_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_message_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.message_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_message_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.message_ids + } + + // Take field + pub fn take_message_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.message_ids, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PublishResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.message_ids)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.message_ids { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.message_ids { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PublishResponse { + PublishResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message_ids", + |m: &PublishResponse| { &m.message_ids }, + |m: &mut PublishResponse| { &mut m.message_ids }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PublishResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PublishResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PublishResponse, + }; + unsafe { + instance.get(PublishResponse::new) + } + } +} + +impl ::protobuf::Clear for PublishResponse { + fn clear(&mut self) { + self.message_ids.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PublishResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PublishResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicsRequest { + // message fields + pub project: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicsRequest { + fn default() -> &'a ListTopicsRequest { + ::default_instance() + } +} + +impl ListTopicsRequest { + pub fn new() -> ListTopicsRequest { + ::std::default::Default::default() + } + + // string project = 1; + + + pub fn get_project(&self) -> &str { + &self.project + } + pub fn clear_project(&mut self) { + self.project.clear(); + } + + // Param is passed by value, moved + pub fn set_project(&mut self, v: ::std::string::String) { + self.project = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_project(&mut self) -> &mut ::std::string::String { + &mut self.project + } + + // Take field + pub fn take_project(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.project, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.project)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.project.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.project); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.project.is_empty() { + os.write_string(1, &self.project)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicsRequest { + ListTopicsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "project", + |m: &ListTopicsRequest| { &m.project }, + |m: &mut ListTopicsRequest| { &mut m.project }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTopicsRequest| { &m.page_size }, + |m: &mut ListTopicsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTopicsRequest| { &m.page_token }, + |m: &mut ListTopicsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicsRequest, + }; + unsafe { + instance.get(ListTopicsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTopicsRequest { + fn clear(&mut self) { + self.project.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicsResponse { + // message fields + pub topics: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicsResponse { + fn default() -> &'a ListTopicsResponse { + ::default_instance() + } +} + +impl ListTopicsResponse { + pub fn new() -> ListTopicsResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1beta2.Topic topics = 1; + + + pub fn get_topics(&self) -> &[Topic] { + &self.topics + } + pub fn clear_topics(&mut self) { + self.topics.clear(); + } + + // Param is passed by value, moved + pub fn set_topics(&mut self, v: ::protobuf::RepeatedField) { + self.topics = v; + } + + // Mutable pointer to the field. + pub fn mut_topics(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.topics + } + + // Take field + pub fn take_topics(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.topics, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicsResponse { + fn is_initialized(&self) -> bool { + for v in &self.topics { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.topics)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.topics { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.topics { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicsResponse { + ListTopicsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "topics", + |m: &ListTopicsResponse| { &m.topics }, + |m: &mut ListTopicsResponse| { &mut m.topics }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTopicsResponse| { &m.next_page_token }, + |m: &mut ListTopicsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicsResponse, + }; + unsafe { + instance.get(ListTopicsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTopicsResponse { + fn clear(&mut self) { + self.topics.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSubscriptionsRequest { + // message fields + pub topic: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSubscriptionsRequest { + fn default() -> &'a ListTopicSubscriptionsRequest { + ::default_instance() + } +} + +impl ListTopicSubscriptionsRequest { + pub fn new() -> ListTopicSubscriptionsRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSubscriptionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSubscriptionsRequest { + ListTopicSubscriptionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &ListTopicSubscriptionsRequest| { &m.topic }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListTopicSubscriptionsRequest| { &m.page_size }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListTopicSubscriptionsRequest| { &m.page_token }, + |m: &mut ListTopicSubscriptionsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSubscriptionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSubscriptionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSubscriptionsRequest, + }; + unsafe { + instance.get(ListTopicSubscriptionsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSubscriptionsRequest { + fn clear(&mut self) { + self.topic.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSubscriptionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSubscriptionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListTopicSubscriptionsResponse { + // message fields + pub subscriptions: ::protobuf::RepeatedField<::std::string::String>, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListTopicSubscriptionsResponse { + fn default() -> &'a ListTopicSubscriptionsResponse { + ::default_instance() + } +} + +impl ListTopicSubscriptionsResponse { + pub fn new() -> ListTopicSubscriptionsResponse { + ::std::default::Default::default() + } + + // repeated string subscriptions = 1; + + + pub fn get_subscriptions(&self) -> &[::std::string::String] { + &self.subscriptions + } + pub fn clear_subscriptions(&mut self) { + self.subscriptions.clear(); + } + + // Param is passed by value, moved + pub fn set_subscriptions(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.subscriptions = v; + } + + // Mutable pointer to the field. + pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.subscriptions + } + + // Take field + pub fn take_subscriptions(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.subscriptions, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListTopicSubscriptionsResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.subscriptions)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.subscriptions { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.subscriptions { + os.write_string(1, &v)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListTopicSubscriptionsResponse { + ListTopicSubscriptionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscriptions", + |m: &ListTopicSubscriptionsResponse| { &m.subscriptions }, + |m: &mut ListTopicSubscriptionsResponse| { &mut m.subscriptions }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListTopicSubscriptionsResponse| { &m.next_page_token }, + |m: &mut ListTopicSubscriptionsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListTopicSubscriptionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListTopicSubscriptionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListTopicSubscriptionsResponse, + }; + unsafe { + instance.get(ListTopicSubscriptionsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListTopicSubscriptionsResponse { + fn clear(&mut self) { + self.subscriptions.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListTopicSubscriptionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListTopicSubscriptionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteTopicRequest { + // message fields + pub topic: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteTopicRequest { + fn default() -> &'a DeleteTopicRequest { + ::default_instance() + } +} + +impl DeleteTopicRequest { + pub fn new() -> DeleteTopicRequest { + ::std::default::Default::default() + } + + // string topic = 1; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteTopicRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.topic); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.topic.is_empty() { + os.write_string(1, &self.topic)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteTopicRequest { + DeleteTopicRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &DeleteTopicRequest| { &m.topic }, + |m: &mut DeleteTopicRequest| { &mut m.topic }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteTopicRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteTopicRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteTopicRequest, + }; + unsafe { + instance.get(DeleteTopicRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteTopicRequest { + fn clear(&mut self) { + self.topic.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteTopicRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteTopicRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Subscription { + // message fields + pub name: ::std::string::String, + pub topic: ::std::string::String, + pub push_config: ::protobuf::SingularPtrField, + pub ack_deadline_seconds: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Subscription { + fn default() -> &'a Subscription { + ::default_instance() + } +} + +impl Subscription { + pub fn new() -> Subscription { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string topic = 2; + + + pub fn get_topic(&self) -> &str { + &self.topic + } + pub fn clear_topic(&mut self) { + self.topic.clear(); + } + + // Param is passed by value, moved + pub fn set_topic(&mut self, v: ::std::string::String) { + self.topic = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_topic(&mut self) -> &mut ::std::string::String { + &mut self.topic + } + + // Take field + pub fn take_topic(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.topic, ::std::string::String::new()) + } + + // .google.pubsub.v1beta2.PushConfig push_config = 4; + + + pub fn get_push_config(&self) -> &PushConfig { + self.push_config.as_ref().unwrap_or_else(|| PushConfig::default_instance()) + } + pub fn clear_push_config(&mut self) { + self.push_config.clear(); + } + + pub fn has_push_config(&self) -> bool { + self.push_config.is_some() + } + + // Param is passed by value, moved + pub fn set_push_config(&mut self, v: PushConfig) { + self.push_config = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_config(&mut self) -> &mut PushConfig { + if self.push_config.is_none() { + self.push_config.set_default(); + } + self.push_config.as_mut().unwrap() + } + + // Take field + pub fn take_push_config(&mut self) -> PushConfig { + self.push_config.take().unwrap_or_else(|| PushConfig::new()) + } + + // int32 ack_deadline_seconds = 5; + + + pub fn get_ack_deadline_seconds(&self) -> i32 { + self.ack_deadline_seconds + } + pub fn clear_ack_deadline_seconds(&mut self) { + self.ack_deadline_seconds = 0; + } + + // Param is passed by value, moved + pub fn set_ack_deadline_seconds(&mut self, v: i32) { + self.ack_deadline_seconds = v; + } +} + +impl ::protobuf::Message for Subscription { + fn is_initialized(&self) -> bool { + for v in &self.push_config { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.topic)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.ack_deadline_seconds = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.topic.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.topic); + } + if let Some(ref v) = self.push_config.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.ack_deadline_seconds != 0 { + my_size += ::protobuf::rt::value_size(5, self.ack_deadline_seconds, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.topic.is_empty() { + os.write_string(2, &self.topic)?; + } + if let Some(ref v) = self.push_config.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.ack_deadline_seconds != 0 { + os.write_int32(5, self.ack_deadline_seconds)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Subscription { + Subscription::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Subscription| { &m.name }, + |m: &mut Subscription| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "topic", + |m: &Subscription| { &m.topic }, + |m: &mut Subscription| { &mut m.topic }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "push_config", + |m: &Subscription| { &m.push_config }, + |m: &mut Subscription| { &mut m.push_config }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "ack_deadline_seconds", + |m: &Subscription| { &m.ack_deadline_seconds }, + |m: &mut Subscription| { &mut m.ack_deadline_seconds }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Subscription", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Subscription { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Subscription, + }; + unsafe { + instance.get(Subscription::new) + } + } +} + +impl ::protobuf::Clear for Subscription { + fn clear(&mut self) { + self.name.clear(); + self.topic.clear(); + self.push_config.clear(); + self.ack_deadline_seconds = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Subscription { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Subscription { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PushConfig { + // message fields + pub push_endpoint: ::std::string::String, + pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PushConfig { + fn default() -> &'a PushConfig { + ::default_instance() + } +} + +impl PushConfig { + pub fn new() -> PushConfig { + ::std::default::Default::default() + } + + // string push_endpoint = 1; + + + pub fn get_push_endpoint(&self) -> &str { + &self.push_endpoint + } + pub fn clear_push_endpoint(&mut self) { + self.push_endpoint.clear(); + } + + // Param is passed by value, moved + pub fn set_push_endpoint(&mut self, v: ::std::string::String) { + self.push_endpoint = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_endpoint(&mut self) -> &mut ::std::string::String { + &mut self.push_endpoint + } + + // Take field + pub fn take_push_endpoint(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.push_endpoint, ::std::string::String::new()) + } + + // repeated .google.pubsub.v1beta2.PushConfig.AttributesEntry attributes = 2; + + + pub fn get_attributes(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.attributes + } + pub fn clear_attributes(&mut self) { + self.attributes.clear(); + } + + // Param is passed by value, moved + pub fn set_attributes(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.attributes = v; + } + + // Mutable pointer to the field. + pub fn mut_attributes(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.attributes + } + + // Take field + pub fn take_attributes(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.attributes, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for PushConfig { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.push_endpoint)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.attributes)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.push_endpoint.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.push_endpoint); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.push_endpoint.is_empty() { + os.write_string(1, &self.push_endpoint)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.attributes, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PushConfig { + PushConfig::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "push_endpoint", + |m: &PushConfig| { &m.push_endpoint }, + |m: &mut PushConfig| { &mut m.push_endpoint }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "attributes", + |m: &PushConfig| { &m.attributes }, + |m: &mut PushConfig| { &mut m.attributes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PushConfig", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PushConfig { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PushConfig, + }; + unsafe { + instance.get(PushConfig::new) + } + } +} + +impl ::protobuf::Clear for PushConfig { + fn clear(&mut self) { + self.push_endpoint.clear(); + self.attributes.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PushConfig { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PushConfig { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReceivedMessage { + // message fields + pub ack_id: ::std::string::String, + pub message: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReceivedMessage { + fn default() -> &'a ReceivedMessage { + ::default_instance() + } +} + +impl ReceivedMessage { + pub fn new() -> ReceivedMessage { + ::std::default::Default::default() + } + + // string ack_id = 1; + + + pub fn get_ack_id(&self) -> &str { + &self.ack_id + } + pub fn clear_ack_id(&mut self) { + self.ack_id.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_id(&mut self, v: ::std::string::String) { + self.ack_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ack_id(&mut self) -> &mut ::std::string::String { + &mut self.ack_id + } + + // Take field + pub fn take_ack_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.ack_id, ::std::string::String::new()) + } + + // .google.pubsub.v1beta2.PubsubMessage message = 2; + + + pub fn get_message(&self) -> &PubsubMessage { + self.message.as_ref().unwrap_or_else(|| PubsubMessage::default_instance()) + } + pub fn clear_message(&mut self) { + self.message.clear(); + } + + pub fn has_message(&self) -> bool { + self.message.is_some() + } + + // Param is passed by value, moved + pub fn set_message(&mut self, v: PubsubMessage) { + self.message = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message(&mut self) -> &mut PubsubMessage { + if self.message.is_none() { + self.message.set_default(); + } + self.message.as_mut().unwrap() + } + + // Take field + pub fn take_message(&mut self) -> PubsubMessage { + self.message.take().unwrap_or_else(|| PubsubMessage::new()) + } +} + +impl ::protobuf::Message for ReceivedMessage { + fn is_initialized(&self) -> bool { + for v in &self.message { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ack_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.ack_id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.ack_id); + } + if let Some(ref v) = self.message.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.ack_id.is_empty() { + os.write_string(1, &self.ack_id)?; + } + if let Some(ref v) = self.message.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReceivedMessage { + ReceivedMessage::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_id", + |m: &ReceivedMessage| { &m.ack_id }, + |m: &mut ReceivedMessage| { &mut m.ack_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "message", + |m: &ReceivedMessage| { &m.message }, + |m: &mut ReceivedMessage| { &mut m.message }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReceivedMessage", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReceivedMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReceivedMessage, + }; + unsafe { + instance.get(ReceivedMessage::new) + } + } +} + +impl ::protobuf::Clear for ReceivedMessage { + fn clear(&mut self) { + self.ack_id.clear(); + self.message.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReceivedMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReceivedMessage { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetSubscriptionRequest { + // message fields + pub subscription: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetSubscriptionRequest { + fn default() -> &'a GetSubscriptionRequest { + ::default_instance() + } +} + +impl GetSubscriptionRequest { + pub fn new() -> GetSubscriptionRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetSubscriptionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetSubscriptionRequest { + GetSubscriptionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &GetSubscriptionRequest| { &m.subscription }, + |m: &mut GetSubscriptionRequest| { &mut m.subscription }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetSubscriptionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetSubscriptionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetSubscriptionRequest, + }; + unsafe { + instance.get(GetSubscriptionRequest::new) + } + } +} + +impl ::protobuf::Clear for GetSubscriptionRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetSubscriptionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetSubscriptionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSubscriptionsRequest { + // message fields + pub project: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSubscriptionsRequest { + fn default() -> &'a ListSubscriptionsRequest { + ::default_instance() + } +} + +impl ListSubscriptionsRequest { + pub fn new() -> ListSubscriptionsRequest { + ::std::default::Default::default() + } + + // string project = 1; + + + pub fn get_project(&self) -> &str { + &self.project + } + pub fn clear_project(&mut self) { + self.project.clear(); + } + + // Param is passed by value, moved + pub fn set_project(&mut self, v: ::std::string::String) { + self.project = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_project(&mut self) -> &mut ::std::string::String { + &mut self.project + } + + // Take field + pub fn take_project(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.project, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSubscriptionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.project)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.project.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.project); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.project.is_empty() { + os.write_string(1, &self.project)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSubscriptionsRequest { + ListSubscriptionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "project", + |m: &ListSubscriptionsRequest| { &m.project }, + |m: &mut ListSubscriptionsRequest| { &mut m.project }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListSubscriptionsRequest| { &m.page_size }, + |m: &mut ListSubscriptionsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListSubscriptionsRequest| { &m.page_token }, + |m: &mut ListSubscriptionsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSubscriptionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSubscriptionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSubscriptionsRequest, + }; + unsafe { + instance.get(ListSubscriptionsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListSubscriptionsRequest { + fn clear(&mut self) { + self.project.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSubscriptionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSubscriptionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSubscriptionsResponse { + // message fields + pub subscriptions: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSubscriptionsResponse { + fn default() -> &'a ListSubscriptionsResponse { + ::default_instance() + } +} + +impl ListSubscriptionsResponse { + pub fn new() -> ListSubscriptionsResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1beta2.Subscription subscriptions = 1; + + + pub fn get_subscriptions(&self) -> &[Subscription] { + &self.subscriptions + } + pub fn clear_subscriptions(&mut self) { + self.subscriptions.clear(); + } + + // Param is passed by value, moved + pub fn set_subscriptions(&mut self, v: ::protobuf::RepeatedField) { + self.subscriptions = v; + } + + // Mutable pointer to the field. + pub fn mut_subscriptions(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.subscriptions + } + + // Take field + pub fn take_subscriptions(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.subscriptions, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSubscriptionsResponse { + fn is_initialized(&self) -> bool { + for v in &self.subscriptions { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.subscriptions)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.subscriptions { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.subscriptions { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSubscriptionsResponse { + ListSubscriptionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "subscriptions", + |m: &ListSubscriptionsResponse| { &m.subscriptions }, + |m: &mut ListSubscriptionsResponse| { &mut m.subscriptions }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListSubscriptionsResponse| { &m.next_page_token }, + |m: &mut ListSubscriptionsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSubscriptionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSubscriptionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSubscriptionsResponse, + }; + unsafe { + instance.get(ListSubscriptionsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListSubscriptionsResponse { + fn clear(&mut self) { + self.subscriptions.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSubscriptionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSubscriptionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteSubscriptionRequest { + // message fields + pub subscription: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteSubscriptionRequest { + fn default() -> &'a DeleteSubscriptionRequest { + ::default_instance() + } +} + +impl DeleteSubscriptionRequest { + pub fn new() -> DeleteSubscriptionRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteSubscriptionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteSubscriptionRequest { + DeleteSubscriptionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &DeleteSubscriptionRequest| { &m.subscription }, + |m: &mut DeleteSubscriptionRequest| { &mut m.subscription }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteSubscriptionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteSubscriptionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteSubscriptionRequest, + }; + unsafe { + instance.get(DeleteSubscriptionRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteSubscriptionRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteSubscriptionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteSubscriptionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyPushConfigRequest { + // message fields + pub subscription: ::std::string::String, + pub push_config: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyPushConfigRequest { + fn default() -> &'a ModifyPushConfigRequest { + ::default_instance() + } +} + +impl ModifyPushConfigRequest { + pub fn new() -> ModifyPushConfigRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // .google.pubsub.v1beta2.PushConfig push_config = 2; + + + pub fn get_push_config(&self) -> &PushConfig { + self.push_config.as_ref().unwrap_or_else(|| PushConfig::default_instance()) + } + pub fn clear_push_config(&mut self) { + self.push_config.clear(); + } + + pub fn has_push_config(&self) -> bool { + self.push_config.is_some() + } + + // Param is passed by value, moved + pub fn set_push_config(&mut self, v: PushConfig) { + self.push_config = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_push_config(&mut self) -> &mut PushConfig { + if self.push_config.is_none() { + self.push_config.set_default(); + } + self.push_config.as_mut().unwrap() + } + + // Take field + pub fn take_push_config(&mut self) -> PushConfig { + self.push_config.take().unwrap_or_else(|| PushConfig::new()) + } +} + +impl ::protobuf::Message for ModifyPushConfigRequest { + fn is_initialized(&self) -> bool { + for v in &self.push_config { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.push_config)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if let Some(ref v) = self.push_config.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if let Some(ref v) = self.push_config.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyPushConfigRequest { + ModifyPushConfigRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &ModifyPushConfigRequest| { &m.subscription }, + |m: &mut ModifyPushConfigRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "push_config", + |m: &ModifyPushConfigRequest| { &m.push_config }, + |m: &mut ModifyPushConfigRequest| { &mut m.push_config }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyPushConfigRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyPushConfigRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyPushConfigRequest, + }; + unsafe { + instance.get(ModifyPushConfigRequest::new) + } + } +} + +impl ::protobuf::Clear for ModifyPushConfigRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.push_config.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyPushConfigRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyPushConfigRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PullRequest { + // message fields + pub subscription: ::std::string::String, + pub return_immediately: bool, + pub max_messages: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PullRequest { + fn default() -> &'a PullRequest { + ::default_instance() + } +} + +impl PullRequest { + pub fn new() -> PullRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // bool return_immediately = 2; + + + pub fn get_return_immediately(&self) -> bool { + self.return_immediately + } + pub fn clear_return_immediately(&mut self) { + self.return_immediately = false; + } + + // Param is passed by value, moved + pub fn set_return_immediately(&mut self, v: bool) { + self.return_immediately = v; + } + + // int32 max_messages = 3; + + + pub fn get_max_messages(&self) -> i32 { + self.max_messages + } + pub fn clear_max_messages(&mut self) { + self.max_messages = 0; + } + + // Param is passed by value, moved + pub fn set_max_messages(&mut self, v: i32) { + self.max_messages = v; + } +} + +impl ::protobuf::Message for PullRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.return_immediately = tmp; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.max_messages = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if self.return_immediately != false { + my_size += 2; + } + if self.max_messages != 0 { + my_size += ::protobuf::rt::value_size(3, self.max_messages, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if self.return_immediately != false { + os.write_bool(2, self.return_immediately)?; + } + if self.max_messages != 0 { + os.write_int32(3, self.max_messages)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PullRequest { + PullRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &PullRequest| { &m.subscription }, + |m: &mut PullRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "return_immediately", + |m: &PullRequest| { &m.return_immediately }, + |m: &mut PullRequest| { &mut m.return_immediately }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "max_messages", + |m: &PullRequest| { &m.max_messages }, + |m: &mut PullRequest| { &mut m.max_messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PullRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PullRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PullRequest, + }; + unsafe { + instance.get(PullRequest::new) + } + } +} + +impl ::protobuf::Clear for PullRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.return_immediately = false; + self.max_messages = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PullRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PullRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PullResponse { + // message fields + pub received_messages: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PullResponse { + fn default() -> &'a PullResponse { + ::default_instance() + } +} + +impl PullResponse { + pub fn new() -> PullResponse { + ::std::default::Default::default() + } + + // repeated .google.pubsub.v1beta2.ReceivedMessage received_messages = 1; + + + pub fn get_received_messages(&self) -> &[ReceivedMessage] { + &self.received_messages + } + pub fn clear_received_messages(&mut self) { + self.received_messages.clear(); + } + + // Param is passed by value, moved + pub fn set_received_messages(&mut self, v: ::protobuf::RepeatedField) { + self.received_messages = v; + } + + // Mutable pointer to the field. + pub fn mut_received_messages(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.received_messages + } + + // Take field + pub fn take_received_messages(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.received_messages, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PullResponse { + fn is_initialized(&self) -> bool { + for v in &self.received_messages { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.received_messages)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.received_messages { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.received_messages { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PullResponse { + PullResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "received_messages", + |m: &PullResponse| { &m.received_messages }, + |m: &mut PullResponse| { &mut m.received_messages }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PullResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PullResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PullResponse, + }; + unsafe { + instance.get(PullResponse::new) + } + } +} + +impl ::protobuf::Clear for PullResponse { + fn clear(&mut self) { + self.received_messages.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PullResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PullResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ModifyAckDeadlineRequest { + // message fields + pub subscription: ::std::string::String, + pub ack_id: ::std::string::String, + pub ack_deadline_seconds: i32, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ModifyAckDeadlineRequest { + fn default() -> &'a ModifyAckDeadlineRequest { + ::default_instance() + } +} + +impl ModifyAckDeadlineRequest { + pub fn new() -> ModifyAckDeadlineRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // string ack_id = 2; + + + pub fn get_ack_id(&self) -> &str { + &self.ack_id + } + pub fn clear_ack_id(&mut self) { + self.ack_id.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_id(&mut self, v: ::std::string::String) { + self.ack_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ack_id(&mut self) -> &mut ::std::string::String { + &mut self.ack_id + } + + // Take field + pub fn take_ack_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.ack_id, ::std::string::String::new()) + } + + // int32 ack_deadline_seconds = 3; + + + pub fn get_ack_deadline_seconds(&self) -> i32 { + self.ack_deadline_seconds + } + pub fn clear_ack_deadline_seconds(&mut self) { + self.ack_deadline_seconds = 0; + } + + // Param is passed by value, moved + pub fn set_ack_deadline_seconds(&mut self, v: i32) { + self.ack_deadline_seconds = v; + } +} + +impl ::protobuf::Message for ModifyAckDeadlineRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ack_id)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.ack_deadline_seconds = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + if !self.ack_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.ack_id); + } + if self.ack_deadline_seconds != 0 { + my_size += ::protobuf::rt::value_size(3, self.ack_deadline_seconds, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + if !self.ack_id.is_empty() { + os.write_string(2, &self.ack_id)?; + } + if self.ack_deadline_seconds != 0 { + os.write_int32(3, self.ack_deadline_seconds)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ModifyAckDeadlineRequest { + ModifyAckDeadlineRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &ModifyAckDeadlineRequest| { &m.subscription }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_id", + |m: &ModifyAckDeadlineRequest| { &m.ack_id }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "ack_deadline_seconds", + |m: &ModifyAckDeadlineRequest| { &m.ack_deadline_seconds }, + |m: &mut ModifyAckDeadlineRequest| { &mut m.ack_deadline_seconds }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ModifyAckDeadlineRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ModifyAckDeadlineRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ModifyAckDeadlineRequest, + }; + unsafe { + instance.get(ModifyAckDeadlineRequest::new) + } + } +} + +impl ::protobuf::Clear for ModifyAckDeadlineRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.ack_id.clear(); + self.ack_deadline_seconds = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ModifyAckDeadlineRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ModifyAckDeadlineRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct AcknowledgeRequest { + // message fields + pub subscription: ::std::string::String, + pub ack_ids: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a AcknowledgeRequest { + fn default() -> &'a AcknowledgeRequest { + ::default_instance() + } +} + +impl AcknowledgeRequest { + pub fn new() -> AcknowledgeRequest { + ::std::default::Default::default() + } + + // string subscription = 1; + + + pub fn get_subscription(&self) -> &str { + &self.subscription + } + pub fn clear_subscription(&mut self) { + self.subscription.clear(); + } + + // Param is passed by value, moved + pub fn set_subscription(&mut self, v: ::std::string::String) { + self.subscription = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subscription(&mut self) -> &mut ::std::string::String { + &mut self.subscription + } + + // Take field + pub fn take_subscription(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subscription, ::std::string::String::new()) + } + + // repeated string ack_ids = 2; + + + pub fn get_ack_ids(&self) -> &[::std::string::String] { + &self.ack_ids + } + pub fn clear_ack_ids(&mut self) { + self.ack_ids.clear(); + } + + // Param is passed by value, moved + pub fn set_ack_ids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.ack_ids = v; + } + + // Mutable pointer to the field. + pub fn mut_ack_ids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.ack_ids + } + + // Take field + pub fn take_ack_ids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.ack_ids, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for AcknowledgeRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subscription)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.ack_ids)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subscription.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subscription); + } + for value in &self.ack_ids { + my_size += ::protobuf::rt::string_size(2, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subscription.is_empty() { + os.write_string(1, &self.subscription)?; + } + for v in &self.ack_ids { + os.write_string(2, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> AcknowledgeRequest { + AcknowledgeRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subscription", + |m: &AcknowledgeRequest| { &m.subscription }, + |m: &mut AcknowledgeRequest| { &mut m.subscription }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "ack_ids", + |m: &AcknowledgeRequest| { &m.ack_ids }, + |m: &mut AcknowledgeRequest| { &mut m.ack_ids }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "AcknowledgeRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static AcknowledgeRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const AcknowledgeRequest, + }; + unsafe { + instance.get(AcknowledgeRequest::new) + } + } +} + +impl ::protobuf::Clear for AcknowledgeRequest { + fn clear(&mut self) { + self.subscription.clear(); + self.ack_ids.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for AcknowledgeRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for AcknowledgeRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\"google/pubsub/v1beta2/pubsub.proto\x12\x15google.pubsub.v1beta2\x1a\ + \x1bgoogle/protobuf/empty.proto\"\x1b\n\x05Topic\x12\x12\n\x04name\x18\ + \x01\x20\x01(\tR\x04name\"\xd7\x01\n\rPubsubMessage\x12\x12\n\x04data\ + \x18\x01\x20\x01(\x0cR\x04data\x12T\n\nattributes\x18\x02\x20\x03(\x0b24\ + .google.pubsub.v1beta2.PubsubMessage.AttributesEntryR\nattributes\x12\ + \x1d\n\nmessage_id\x18\x03\x20\x01(\tR\tmessageId\x1a=\n\x0fAttributesEn\ + try\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\ + \x02\x20\x01(\tR\x05value:\x028\x01\"'\n\x0fGetTopicRequest\x12\x14\n\ + \x05topic\x18\x01\x20\x01(\tR\x05topic\"h\n\x0ePublishRequest\x12\x14\n\ + \x05topic\x18\x01\x20\x01(\tR\x05topic\x12@\n\x08messages\x18\x02\x20\ + \x03(\x0b2$.google.pubsub.v1beta2.PubsubMessageR\x08messages\"2\n\x0fPub\ + lishResponse\x12\x1f\n\x0bmessage_ids\x18\x01\x20\x03(\tR\nmessageIds\"i\ + \n\x11ListTopicsRequest\x12\x18\n\x07project\x18\x01\x20\x01(\tR\x07proj\ + ect\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\npa\ + ge_token\x18\x03\x20\x01(\tR\tpageToken\"r\n\x12ListTopicsResponse\x124\ + \n\x06topics\x18\x01\x20\x03(\x0b2\x1c.google.pubsub.v1beta2.TopicR\x06t\ + opics\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"q\n\ + \x1dListTopicSubscriptionsRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\ + \x05topic\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\ + \n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"n\n\x1eListTopicSubscript\ + ionsResponse\x12$\n\rsubscriptions\x18\x01\x20\x03(\tR\rsubscriptions\ + \x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"*\n\x12De\ + leteTopicRequest\x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05topic\"\xae\ + \x01\n\x0cSubscription\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\ + \x14\n\x05topic\x18\x02\x20\x01(\tR\x05topic\x12B\n\x0bpush_config\x18\ + \x04\x20\x01(\x0b2!.google.pubsub.v1beta2.PushConfigR\npushConfig\x120\n\ + \x14ack_deadline_seconds\x18\x05\x20\x01(\x05R\x12ackDeadlineSeconds\"\ + \xc3\x01\n\nPushConfig\x12#\n\rpush_endpoint\x18\x01\x20\x01(\tR\x0cpush\ + Endpoint\x12Q\n\nattributes\x18\x02\x20\x03(\x0b21.google.pubsub.v1beta2\ + .PushConfig.AttributesEntryR\nattributes\x1a=\n\x0fAttributesEntry\x12\ + \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\ + \x01(\tR\x05value:\x028\x01\"h\n\x0fReceivedMessage\x12\x15\n\x06ack_id\ + \x18\x01\x20\x01(\tR\x05ackId\x12>\n\x07message\x18\x02\x20\x01(\x0b2$.g\ + oogle.pubsub.v1beta2.PubsubMessageR\x07message\"<\n\x16GetSubscriptionRe\ + quest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\"p\n\ + \x18ListSubscriptionsRequest\x12\x18\n\x07project\x18\x01\x20\x01(\tR\ + \x07project\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\ + \x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\x8e\x01\n\x19ListSub\ + scriptionsResponse\x12I\n\rsubscriptions\x18\x01\x20\x03(\x0b2#.google.p\ + ubsub.v1beta2.SubscriptionR\rsubscriptions\x12&\n\x0fnext_page_token\x18\ + \x02\x20\x01(\tR\rnextPageToken\"?\n\x19DeleteSubscriptionRequest\x12\"\ + \n\x0csubscription\x18\x01\x20\x01(\tR\x0csubscription\"\x81\x01\n\x17Mo\ + difyPushConfigRequest\x12\"\n\x0csubscription\x18\x01\x20\x01(\tR\x0csub\ + scription\x12B\n\x0bpush_config\x18\x02\x20\x01(\x0b2!.google.pubsub.v1b\ + eta2.PushConfigR\npushConfig\"\x83\x01\n\x0bPullRequest\x12\"\n\x0csubsc\ + ription\x18\x01\x20\x01(\tR\x0csubscription\x12-\n\x12return_immediately\ + \x18\x02\x20\x01(\x08R\x11returnImmediately\x12!\n\x0cmax_messages\x18\ + \x03\x20\x01(\x05R\x0bmaxMessages\"c\n\x0cPullResponse\x12S\n\x11receive\ + d_messages\x18\x01\x20\x03(\x0b2&.google.pubsub.v1beta2.ReceivedMessageR\ + \x10receivedMessages\"\x87\x01\n\x18ModifyAckDeadlineRequest\x12\"\n\x0c\ + subscription\x18\x01\x20\x01(\tR\x0csubscription\x12\x15\n\x06ack_id\x18\ + \x02\x20\x01(\tR\x05ackId\x120\n\x14ack_deadline_seconds\x18\x03\x20\x01\ + (\x05R\x12ackDeadlineSeconds\"Q\n\x12AcknowledgeRequest\x12\"\n\x0csubsc\ + ription\x18\x01\x20\x01(\tR\x0csubscription\x12\x17\n\x07ack_ids\x18\x02\ + \x20\x03(\tR\x06ackIds2\x88\x06\n\nSubscriber\x12^\n\x12CreateSubscripti\ + on\x12#.google.pubsub.v1beta2.Subscription\x1a#.google.pubsub.v1beta2.Su\ + bscription\x12e\n\x0fGetSubscription\x12-.google.pubsub.v1beta2.GetSubsc\ + riptionRequest\x1a#.google.pubsub.v1beta2.Subscription\x12v\n\x11ListSub\ + scriptions\x12/.google.pubsub.v1beta2.ListSubscriptionsRequest\x1a0.goog\ + le.pubsub.v1beta2.ListSubscriptionsResponse\x12^\n\x12DeleteSubscription\ + \x120.google.pubsub.v1beta2.DeleteSubscriptionRequest\x1a\x16.google.pro\ + tobuf.Empty\x12\\\n\x11ModifyAckDeadline\x12/.google.pubsub.v1beta2.Modi\ + fyAckDeadlineRequest\x1a\x16.google.protobuf.Empty\x12P\n\x0bAcknowledge\ + \x12).google.pubsub.v1beta2.AcknowledgeRequest\x1a\x16.google.protobuf.E\ + mpty\x12O\n\x04Pull\x12\".google.pubsub.v1beta2.PullRequest\x1a#.google.\ + pubsub.v1beta2.PullResponse\x12Z\n\x10ModifyPushConfig\x12..google.pubsu\ + b.v1beta2.ModifyPushConfigRequest\x1a\x16.google.protobuf.Empty2\xbf\x04\ + \n\tPublisher\x12I\n\x0bCreateTopic\x12\x1c.google.pubsub.v1beta2.Topic\ + \x1a\x1c.google.pubsub.v1beta2.Topic\x12X\n\x07Publish\x12%.google.pubsu\ + b.v1beta2.PublishRequest\x1a&.google.pubsub.v1beta2.PublishResponse\x12P\ + \n\x08GetTopic\x12&.google.pubsub.v1beta2.GetTopicRequest\x1a\x1c.google\ + .pubsub.v1beta2.Topic\x12a\n\nListTopics\x12(.google.pubsub.v1beta2.List\ + TopicsRequest\x1a).google.pubsub.v1beta2.ListTopicsResponse\x12\x85\x01\ + \n\x16ListTopicSubscriptions\x124.google.pubsub.v1beta2.ListTopicSubscri\ + ptionsRequest\x1a5.google.pubsub.v1beta2.ListTopicSubscriptionsResponse\ + \x12P\n\x0bDeleteTopic\x12).google.pubsub.v1beta2.DeleteTopicRequest\x1a\ + \x16.google.protobuf.EmptyBg\n\x19com.google.pubsub.v1beta2B\x0bPubsubPr\ + otoP\x01Z;google.golang.org/genproto/googleapis/pubsub/v1beta2;pubsubJ\ + \xe3x\n\x07\x12\x05\x0e\0\xff\x02\x01\n\xc2\x04\n\x01\x0c\x12\x03\x0e\0\ + \x122\xb7\x04\x20Copyright\x20(c)\x202015,\x20Google\x20Inc.\n\n\x20Lice\ + nsed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\ + \"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20except\ + \x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obtai\ + n\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http\ + ://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\ + \x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20softwar\ + e\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\ + \x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CON\ + DITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\ + \x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20gover\ + ning\x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\ + \n\n\x08\n\x01\x02\x12\x03\x10\0\x1e\n\t\n\x02\x03\0\x12\x03\x12\0%\n\ + \x08\n\x01\x08\x12\x03\x14\0R\n\t\n\x02\x08\x0b\x12\x03\x14\0R\n\x08\n\ + \x01\x08\x12\x03\x15\0\"\n\t\n\x02\x08\n\x12\x03\x15\0\"\n\x08\n\x01\x08\ + \x12\x03\x16\0,\n\t\n\x02\x08\x08\x12\x03\x16\0,\n\x08\n\x01\x08\x12\x03\ + \x17\02\n\t\n\x02\x08\x01\x12\x03\x17\02\n\x91\x01\n\x02\x06\0\x12\x04\ + \x1c\0O\x01\x1a\x84\x01\x20The\x20service\x20that\x20an\x20application\ + \x20uses\x20to\x20manipulate\x20subscriptions\x20and\x20to\n\x20consume\ + \x20messages\x20from\x20a\x20subscription\x20via\x20the\x20Pull\x20metho\ + d.\n\n\n\n\x03\x06\0\x01\x12\x03\x1c\x08\x12\n\xd6\x02\n\x04\x06\0\x02\0\ + \x12\x03#\x02>\x1a\xc8\x02\x20Creates\x20a\x20subscription\x20to\x20a\ + \x20given\x20topic\x20for\x20a\x20given\x20subscriber.\n\x20If\x20the\ + \x20subscription\x20already\x20exists,\x20returns\x20ALREADY_EXISTS.\n\ + \x20If\x20the\x20corresponding\x20topic\x20doesn't\x20exist,\x20returns\ + \x20NOT_FOUND.\n\n\x20If\x20the\x20name\x20is\x20not\x20provided\x20in\ + \x20the\x20request,\x20the\x20server\x20will\x20assign\x20a\x20random\n\ + \x20name\x20for\x20this\x20subscription\x20on\x20the\x20same\x20project\ + \x20as\x20the\x20topic.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03#\x06\x18\n\ + \x0c\n\x05\x06\0\x02\0\x02\x12\x03#\x19%\n\x0c\n\x05\x06\0\x02\0\x03\x12\ + \x03#0<\n@\n\x04\x06\0\x02\x01\x12\x03&\x02E\x1a3\x20Gets\x20the\x20conf\ + iguration\x20details\x20of\x20a\x20subscription.\n\n\x0c\n\x05\x06\0\x02\ + \x01\x01\x12\x03&\x06\x15\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03&\x16,\n\ + \x0c\n\x05\x06\0\x02\x01\x03\x12\x03&7C\n,\n\x04\x06\0\x02\x02\x12\x03)\ + \x02V\x1a\x1f\x20Lists\x20matching\x20subscriptions.\n\n\x0c\n\x05\x06\0\ + \x02\x02\x01\x12\x03)\x06\x17\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03)\x18\ + 0\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03);T\n\xe8\x02\n\x04\x06\0\x02\x03\ + \x12\x030\x02T\x1a\xda\x02\x20Deletes\x20an\x20existing\x20subscription.\ + \x20All\x20pending\x20messages\x20in\x20the\x20subscription\n\x20are\x20\ + immediately\x20dropped.\x20Calls\x20to\x20Pull\x20after\x20deletion\x20w\ + ill\x20return\n\x20NOT_FOUND.\x20After\x20a\x20subscription\x20is\x20del\ + eted,\x20a\x20new\x20one\x20may\x20be\x20created\x20with\n\x20the\x20sam\ + e\x20name,\x20but\x20the\x20new\x20one\x20has\x20no\x20association\x20wi\ + th\x20the\x20old\n\x20subscription,\x20or\x20its\x20topic\x20unless\x20t\ + he\x20same\x20topic\x20is\x20specified.\n\n\x0c\n\x05\x06\0\x02\x03\x01\ + \x12\x030\x06\x18\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x030\x192\n\x0c\n\ + \x05\x06\0\x02\x03\x03\x12\x030=R\n\xfa\x01\n\x04\x06\0\x02\x04\x12\x036\ + \x02R\x1a\xec\x01\x20Modifies\x20the\x20ack\x20deadline\x20for\x20a\x20s\ + pecific\x20message.\x20This\x20method\x20is\x20useful\x20to\n\x20indicat\ + e\x20that\x20more\x20time\x20is\x20needed\x20to\x20process\x20a\x20messa\ + ge\x20by\x20the\x20subscriber,\n\x20or\x20to\x20make\x20the\x20message\ + \x20available\x20for\x20redelivery\x20if\x20the\x20processing\x20was\n\ + \x20interrupted.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x036\x06\x17\n\x0c\ + \n\x05\x06\0\x02\x04\x02\x12\x036\x180\n\x0c\n\x05\x06\0\x02\x04\x03\x12\ + \x036;P\n\xe9\x02\n\x04\x06\0\x02\x05\x12\x03?\x02F\x1a\xdb\x02\x20Ackno\ + wledges\x20the\x20messages\x20associated\x20with\x20the\x20ack\x20tokens\ + \x20in\x20the\n\x20AcknowledgeRequest.\x20The\x20Pub/Sub\x20system\x20ca\ + n\x20remove\x20the\x20relevant\x20messages\n\x20from\x20the\x20subscript\ + ion.\n\n\x20Acknowledging\x20a\x20message\x20whose\x20ack\x20deadline\ + \x20has\x20expired\x20may\x20succeed,\n\x20but\x20such\x20a\x20message\ + \x20may\x20be\x20redelivered\x20later.\x20Acknowledging\x20a\x20message\ + \x20more\n\x20than\x20once\x20will\x20not\x20result\x20in\x20an\x20error\ + .\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03?\x06\x11\n\x0c\n\x05\x06\0\x02\ + \x05\x02\x12\x03?\x12$\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03?/D\n\xf0\ + \x01\n\x04\x06\0\x02\x06\x12\x03E\x02/\x1a\xe2\x01\x20Pulls\x20messages\ + \x20from\x20the\x20server.\x20Returns\x20an\x20empty\x20list\x20if\x20th\ + ere\x20are\x20no\n\x20messages\x20available\x20in\x20the\x20backlog.\x20\ + The\x20server\x20may\x20return\x20UNAVAILABLE\x20if\n\x20there\x20are\ + \x20too\x20many\x20concurrent\x20pull\x20requests\x20pending\x20for\x20t\ + he\x20given\n\x20subscription.\n\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03E\ + \x06\n\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03E\x0b\x16\n\x0c\n\x05\x06\0\ + \x02\x06\x03\x12\x03E!-\n\xef\x02\n\x04\x06\0\x02\x07\x12\x03N\x02P\x1a\ + \xe1\x02\x20Modifies\x20the\x20PushConfig\x20for\x20a\x20specified\x20su\ + bscription.\n\n\x20This\x20may\x20be\x20used\x20to\x20change\x20a\x20pus\ + h\x20subscription\x20to\x20a\x20pull\x20one\x20(signified\n\x20by\x20an\ + \x20empty\x20PushConfig)\x20or\x20vice\x20versa,\x20or\x20change\x20the\ + \x20endpoint\x20URL\x20and\x20other\n\x20attributes\x20of\x20a\x20push\ + \x20subscription.\x20Messages\x20will\x20accumulate\x20for\n\x20delivery\ + \x20continuously\x20through\x20the\x20call\x20regardless\x20of\x20change\ + s\x20to\x20the\n\x20PushConfig.\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03N\ + \x06\x16\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03N\x17.\n\x0c\n\x05\x06\0\ + \x02\x07\x03\x12\x03N9N\nj\n\x02\x06\x01\x12\x04S\0j\x01\x1a^\x20The\x20\ + service\x20that\x20an\x20application\x20uses\x20to\x20manipulate\x20topi\ + cs,\x20and\x20to\x20send\n\x20messages\x20to\x20a\x20topic.\n\n\n\n\x03\ + \x06\x01\x01\x12\x03S\x08\x11\n;\n\x04\x06\x01\x02\0\x12\x03U\x02)\x1a.\ + \x20Creates\x20the\x20given\x20topic\x20with\x20the\x20given\x20name.\n\ + \n\x0c\n\x05\x06\x01\x02\0\x01\x12\x03U\x06\x11\n\x0c\n\x05\x06\x01\x02\ + \0\x02\x12\x03U\x12\x17\n\x0c\n\x05\x06\x01\x02\0\x03\x12\x03U\"'\nf\n\ + \x04\x06\x01\x02\x01\x12\x03Y\x028\x1aY\x20Adds\x20one\x20or\x20more\x20\ + messages\x20to\x20the\x20topic.\x20Returns\x20NOT_FOUND\x20if\x20the\x20\ + topic\x20does\n\x20not\x20exist.\n\n\x0c\n\x05\x06\x01\x02\x01\x01\x12\ + \x03Y\x06\r\n\x0c\n\x05\x06\x01\x02\x01\x02\x12\x03Y\x0e\x1c\n\x0c\n\x05\ + \x06\x01\x02\x01\x03\x12\x03Y'6\n1\n\x04\x06\x01\x02\x02\x12\x03\\\x020\ + \x1a$\x20Gets\x20the\x20configuration\x20of\x20a\x20topic.\n\n\x0c\n\x05\ + \x06\x01\x02\x02\x01\x12\x03\\\x06\x0e\n\x0c\n\x05\x06\x01\x02\x02\x02\ + \x12\x03\\\x0f\x1e\n\x0c\n\x05\x06\x01\x02\x02\x03\x12\x03\\).\n%\n\x04\ + \x06\x01\x02\x03\x12\x03_\x02A\x1a\x18\x20Lists\x20matching\x20topics.\n\ + \n\x0c\n\x05\x06\x01\x02\x03\x01\x12\x03_\x06\x10\n\x0c\n\x05\x06\x01\ + \x02\x03\x02\x12\x03_\x11\"\n\x0c\n\x05\x06\x01\x02\x03\x03\x12\x03_-?\n\ + B\n\x04\x06\x01\x02\x04\x12\x03b\x02e\x1a5\x20Lists\x20the\x20name\x20of\ + \x20the\x20subscriptions\x20for\x20this\x20topic.\n\n\x0c\n\x05\x06\x01\ + \x02\x04\x01\x12\x03b\x06\x1c\n\x0c\n\x05\x06\x01\x02\x04\x02\x12\x03b\ + \x1d:\n\x0c\n\x05\x06\x01\x02\x04\x03\x12\x03bEc\n\xbb\x02\n\x04\x06\x01\ + \x02\x05\x12\x03i\x02F\x1a\xad\x02\x20Deletes\x20the\x20topic\x20with\ + \x20the\x20given\x20name.\x20Returns\x20NOT_FOUND\x20if\x20the\x20topic\ + \x20does\n\x20not\x20exist.\x20After\x20a\x20topic\x20is\x20deleted,\x20\ + a\x20new\x20topic\x20may\x20be\x20created\x20with\x20the\n\x20same\x20na\ + me;\x20this\x20is\x20an\x20entirely\x20new\x20topic\x20with\x20none\x20o\ + f\x20the\x20old\n\x20configuration\x20or\x20subscriptions.\x20Existing\ + \x20subscriptions\x20to\x20this\x20topic\x20are\n\x20not\x20deleted.\n\n\ + \x0c\n\x05\x06\x01\x02\x05\x01\x12\x03i\x06\x11\n\x0c\n\x05\x06\x01\x02\ + \x05\x02\x12\x03i\x12$\n\x0c\n\x05\x06\x01\x02\x05\x03\x12\x03i/D\n\x1f\ + \n\x02\x04\0\x12\x04m\0p\x01\x1a\x13\x20A\x20topic\x20resource.\n\n\n\n\ + \x03\x04\0\x01\x12\x03m\x08\r\n!\n\x04\x04\0\x02\0\x12\x03o\x02\x12\x1a\ + \x14\x20Name\x20of\x20the\x20topic.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04o\ + \x02m\x0f\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03o\x02\x08\n\x0c\n\x05\x04\0\ + \x02\0\x01\x12\x03o\t\r\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03o\x10\x11\n1\ + \n\x02\x04\x01\x12\x05s\0\x80\x01\x01\x1a$\x20A\x20message\x20data\x20an\ + d\x20its\x20attributes.\n\n\n\n\x03\x04\x01\x01\x12\x03s\x08\x15\ng\n\ + \x04\x04\x01\x02\0\x12\x03v\x02\x11\x1aZ\x20The\x20message\x20payload.\ + \x20For\x20JSON\x20requests,\x20the\x20value\x20of\x20this\x20field\x20m\ + ust\x20be\n\x20base64-encoded.\n\n\r\n\x05\x04\x01\x02\0\x04\x12\x04v\ + \x02s\x17\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03v\x02\x07\n\x0c\n\x05\x04\ + \x01\x02\0\x01\x12\x03v\x08\x0c\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03v\ + \x0f\x10\n4\n\x04\x04\x01\x02\x01\x12\x03y\x02%\x1a'\x20Optional\x20attr\ + ibutes\x20for\x20this\x20message.\n\n\r\n\x05\x04\x01\x02\x01\x04\x12\ + \x04y\x02v\x11\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03y\x02\x15\n\x0c\n\ + \x05\x04\x01\x02\x01\x01\x12\x03y\x16\x20\n\x0c\n\x05\x04\x01\x02\x01\ + \x03\x12\x03y#$\n\x9f\x02\n\x04\x04\x01\x02\x02\x12\x03\x7f\x02\x18\x1a\ + \x91\x02\x20ID\x20of\x20this\x20message\x20assigned\x20by\x20the\x20serv\ + er\x20at\x20publication\x20time.\x20Guaranteed\n\x20to\x20be\x20unique\ + \x20within\x20the\x20topic.\x20This\x20value\x20may\x20be\x20read\x20by\ + \x20a\x20subscriber\n\x20that\x20receives\x20a\x20PubsubMessage\x20via\ + \x20a\x20Pull\x20call\x20or\x20a\x20push\x20delivery.\x20It\x20must\n\ + \x20not\x20be\x20populated\x20by\x20a\x20publisher\x20in\x20a\x20Publish\ + \x20call.\n\n\r\n\x05\x04\x01\x02\x02\x04\x12\x04\x7f\x02y%\n\x0c\n\x05\ + \x04\x01\x02\x02\x05\x12\x03\x7f\x02\x08\n\x0c\n\x05\x04\x01\x02\x02\x01\ + \x12\x03\x7f\t\x13\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x7f\x16\x17\n\ + 0\n\x02\x04\x02\x12\x06\x83\x01\0\x86\x01\x01\x1a\"\x20Request\x20for\ + \x20the\x20GetTopic\x20method.\n\n\x0b\n\x03\x04\x02\x01\x12\x04\x83\x01\ + \x08\x17\n-\n\x04\x04\x02\x02\0\x12\x04\x85\x01\x02\x13\x1a\x1f\x20The\ + \x20name\x20of\x20the\x20topic\x20to\x20get.\n\n\x0f\n\x05\x04\x02\x02\0\ + \x04\x12\x06\x85\x01\x02\x83\x01\x19\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\ + \x85\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\x85\x01\t\x0e\n\r\n\ + \x05\x04\x02\x02\0\x03\x12\x04\x85\x01\x11\x12\n/\n\x02\x04\x03\x12\x06\ + \x89\x01\0\x8f\x01\x01\x1a!\x20Request\x20for\x20the\x20Publish\x20metho\ + d.\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x89\x01\x08\x16\nL\n\x04\x04\x03\ + \x02\0\x12\x04\x8b\x01\x02\x13\x1a>\x20The\x20messages\x20in\x20the\x20r\ + equest\x20will\x20be\x20published\x20on\x20this\x20topic.\n\n\x0f\n\x05\ + \x04\x03\x02\0\x04\x12\x06\x8b\x01\x02\x89\x01\x18\n\r\n\x05\x04\x03\x02\ + \0\x05\x12\x04\x8b\x01\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x8b\ + \x01\t\x0e\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x8b\x01\x11\x12\n(\n\x04\ + \x04\x03\x02\x01\x12\x04\x8e\x01\x02&\x1a\x1a\x20The\x20messages\x20to\ + \x20publish.\n\n\r\n\x05\x04\x03\x02\x01\x04\x12\x04\x8e\x01\x02\n\n\r\n\ + \x05\x04\x03\x02\x01\x06\x12\x04\x8e\x01\x0b\x18\n\r\n\x05\x04\x03\x02\ + \x01\x01\x12\x04\x8e\x01\x19!\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\x8e\ + \x01$%\n0\n\x02\x04\x04\x12\x06\x92\x01\0\x97\x01\x01\x1a\"\x20Response\ + \x20for\x20the\x20Publish\x20method.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\ + \x92\x01\x08\x17\n\xa8\x01\n\x04\x04\x04\x02\0\x12\x04\x96\x01\x02\"\x1a\ + \x99\x01\x20The\x20server-assigned\x20ID\x20of\x20each\x20published\x20m\ + essage,\x20in\x20the\x20same\x20order\x20as\n\x20the\x20messages\x20in\ + \x20the\x20request.\x20IDs\x20are\x20guaranteed\x20to\x20be\x20unique\ + \x20within\n\x20the\x20topic.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\x96\ + \x01\x02\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\x96\x01\x0b\x11\n\r\n\x05\ + \x04\x04\x02\0\x01\x12\x04\x96\x01\x12\x1d\n\r\n\x05\x04\x04\x02\0\x03\ + \x12\x04\x96\x01\x20!\n2\n\x02\x04\x05\x12\x06\x9a\x01\0\xa5\x01\x01\x1a\ + $\x20Request\x20for\x20the\x20ListTopics\x20method.\n\n\x0b\n\x03\x04\ + \x05\x01\x12\x04\x9a\x01\x08\x19\nD\n\x04\x04\x05\x02\0\x12\x04\x9c\x01\ + \x02\x15\x1a6\x20The\x20name\x20of\x20the\x20cloud\x20project\x20that\ + \x20topics\x20belong\x20to.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\x9c\ + \x01\x02\x9a\x01\x1b\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x9c\x01\x02\x08\ + \n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x9c\x01\t\x10\n\r\n\x05\x04\x05\x02\ + \0\x03\x12\x04\x9c\x01\x13\x14\n3\n\x04\x04\x05\x02\x01\x12\x04\x9f\x01\ + \x02\x16\x1a%\x20Maximum\x20number\x20of\x20topics\x20to\x20return.\n\n\ + \x0f\n\x05\x04\x05\x02\x01\x04\x12\x06\x9f\x01\x02\x9c\x01\x15\n\r\n\x05\ + \x04\x05\x02\x01\x05\x12\x04\x9f\x01\x02\x07\n\r\n\x05\x04\x05\x02\x01\ + \x01\x12\x04\x9f\x01\x08\x11\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\x9f\ + \x01\x14\x15\n\xc0\x01\n\x04\x04\x05\x02\x02\x12\x04\xa4\x01\x02\x18\x1a\ + \xb1\x01\x20The\x20value\x20returned\x20by\x20the\x20last\x20ListTopicsR\ + esponse;\x20indicates\x20that\x20this\x20is\n\x20a\x20continuation\x20of\ + \x20a\x20prior\x20ListTopics\x20call,\x20and\x20that\x20the\x20system\ + \x20should\n\x20return\x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\ + \x05\x04\x05\x02\x02\x04\x12\x06\xa4\x01\x02\x9f\x01\x16\n\r\n\x05\x04\ + \x05\x02\x02\x05\x12\x04\xa4\x01\x02\x08\n\r\n\x05\x04\x05\x02\x02\x01\ + \x12\x04\xa4\x01\t\x13\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\xa4\x01\x16\ + \x17\n3\n\x02\x04\x06\x12\x06\xa8\x01\0\xaf\x01\x01\x1a%\x20Response\x20\ + for\x20the\x20ListTopics\x20method.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\ + \xa8\x01\x08\x1a\n%\n\x04\x04\x06\x02\0\x12\x04\xaa\x01\x02\x1c\x1a\x17\ + \x20The\x20resulting\x20topics.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04\ + \xaa\x01\x02\n\n\r\n\x05\x04\x06\x02\0\x06\x12\x04\xaa\x01\x0b\x10\n\r\n\ + \x05\x04\x06\x02\0\x01\x12\x04\xaa\x01\x11\x17\n\r\n\x05\x04\x06\x02\0\ + \x03\x12\x04\xaa\x01\x1a\x1b\n\x97\x01\n\x04\x04\x06\x02\x01\x12\x04\xae\ + \x01\x02\x1d\x1a\x88\x01\x20If\x20not\x20empty,\x20indicates\x20that\x20\ + there\x20may\x20be\x20more\x20topics\x20that\x20match\x20the\n\x20reques\ + t;\x20this\x20value\x20should\x20be\x20passed\x20in\x20a\x20new\x20ListT\ + opicsRequest.\n\n\x0f\n\x05\x04\x06\x02\x01\x04\x12\x06\xae\x01\x02\xaa\ + \x01\x1c\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xae\x01\x02\x08\n\r\n\x05\ + \x04\x06\x02\x01\x01\x12\x04\xae\x01\t\x18\n\r\n\x05\x04\x06\x02\x01\x03\ + \x12\x04\xae\x01\x1b\x1c\n>\n\x02\x04\x07\x12\x06\xb2\x01\0\xbd\x01\x01\ + \x1a0\x20Request\x20for\x20the\x20ListTopicSubscriptions\x20method.\n\n\ + \x0b\n\x03\x04\x07\x01\x12\x04\xb2\x01\x08%\nI\n\x04\x04\x07\x02\0\x12\ + \x04\xb4\x01\x02\x13\x1a;\x20The\x20name\x20of\x20the\x20topic\x20that\ + \x20subscriptions\x20are\x20attached\x20to.\n\n\x0f\n\x05\x04\x07\x02\0\ + \x04\x12\x06\xb4\x01\x02\xb2\x01'\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\ + \xb4\x01\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xb4\x01\t\x0e\n\r\n\ + \x05\x04\x07\x02\0\x03\x12\x04\xb4\x01\x11\x12\n?\n\x04\x04\x07\x02\x01\ + \x12\x04\xb7\x01\x02\x16\x1a1\x20Maximum\x20number\x20of\x20subscription\ + \x20names\x20to\x20return.\n\n\x0f\n\x05\x04\x07\x02\x01\x04\x12\x06\xb7\ + \x01\x02\xb4\x01\x13\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\xb7\x01\x02\ + \x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\xb7\x01\x08\x11\n\r\n\x05\x04\ + \x07\x02\x01\x03\x12\x04\xb7\x01\x14\x15\n\xd8\x01\n\x04\x04\x07\x02\x02\ + \x12\x04\xbc\x01\x02\x18\x1a\xc9\x01\x20The\x20value\x20returned\x20by\ + \x20the\x20last\x20ListTopicSubscriptionsResponse;\x20indicates\n\x20tha\ + t\x20this\x20is\x20a\x20continuation\x20of\x20a\x20prior\x20ListTopicSub\ + scriptions\x20call,\x20and\n\x20that\x20the\x20system\x20should\x20retur\ + n\x20the\x20next\x20page\x20of\x20data.\n\n\x0f\n\x05\x04\x07\x02\x02\ + \x04\x12\x06\xbc\x01\x02\xb7\x01\x16\n\r\n\x05\x04\x07\x02\x02\x05\x12\ + \x04\xbc\x01\x02\x08\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\xbc\x01\t\x13\ + \n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\xbc\x01\x16\x17\n?\n\x02\x04\x08\ + \x12\x06\xc0\x01\0\xc8\x01\x01\x1a1\x20Response\x20for\x20the\x20ListTop\ + icSubscriptions\x20method.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xc0\x01\x08\ + &\nF\n\x04\x04\x08\x02\0\x12\x04\xc2\x01\x02$\x1a8\x20The\x20names\x20of\ + \x20the\x20subscriptions\x20that\x20match\x20the\x20request.\n\n\r\n\x05\ + \x04\x08\x02\0\x04\x12\x04\xc2\x01\x02\n\n\r\n\x05\x04\x08\x02\0\x05\x12\ + \x04\xc2\x01\x0b\x11\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xc2\x01\x12\x1f\ + \n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xc2\x01\"#\n\xc5\x01\n\x04\x04\x08\ + \x02\x01\x12\x04\xc7\x01\x02\x1d\x1a\xb6\x01\x20If\x20not\x20empty,\x20i\ + ndicates\x20that\x20there\x20may\x20be\x20more\x20subscriptions\x20that\ + \x20match\n\x20the\x20request;\x20this\x20value\x20should\x20be\x20passe\ + d\x20in\x20a\x20new\n\x20ListTopicSubscriptionsRequest\x20to\x20get\x20m\ + ore\x20subscriptions.\n\n\x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\xc7\x01\ + \x02\xc2\x01$\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xc7\x01\x02\x08\n\r\ + \n\x05\x04\x08\x02\x01\x01\x12\x04\xc7\x01\t\x18\n\r\n\x05\x04\x08\x02\ + \x01\x03\x12\x04\xc7\x01\x1b\x1c\n3\n\x02\x04\t\x12\x06\xcb\x01\0\xce\ + \x01\x01\x1a%\x20Request\x20for\x20the\x20DeleteTopic\x20method.\n\n\x0b\ + \n\x03\x04\t\x01\x12\x04\xcb\x01\x08\x1a\n,\n\x04\x04\t\x02\0\x12\x04\ + \xcd\x01\x02\x13\x1a\x1e\x20Name\x20of\x20the\x20topic\x20to\x20delete.\ + \n\n\x0f\n\x05\x04\t\x02\0\x04\x12\x06\xcd\x01\x02\xcb\x01\x1c\n\r\n\x05\ + \x04\t\x02\0\x05\x12\x04\xcd\x01\x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\ + \x04\xcd\x01\t\x0e\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xcd\x01\x11\x12\n(\ + \n\x02\x04\n\x12\x06\xd1\x01\0\xef\x01\x01\x1a\x1a\x20A\x20subscription\ + \x20resource.\n\n\x0b\n\x03\x04\n\x01\x12\x04\xd1\x01\x08\x14\n)\n\x04\ + \x04\n\x02\0\x12\x04\xd3\x01\x02\x12\x1a\x1b\x20Name\x20of\x20the\x20sub\ + scription.\n\n\x0f\n\x05\x04\n\x02\0\x04\x12\x06\xd3\x01\x02\xd1\x01\x16\ + \n\r\n\x05\x04\n\x02\0\x05\x12\x04\xd3\x01\x02\x08\n\r\n\x05\x04\n\x02\0\ + \x01\x12\x04\xd3\x01\t\r\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xd3\x01\x10\ + \x11\n\xb7\x01\n\x04\x04\n\x02\x01\x12\x04\xd8\x01\x02\x13\x1a\xa8\x01\ + \x20The\x20name\x20of\x20the\x20topic\x20from\x20which\x20this\x20subscr\ + iption\x20is\x20receiving\x20messages.\n\x20This\x20will\x20be\x20presen\ + t\x20if\x20and\x20only\x20if\x20the\x20subscription\x20has\x20not\x20bee\ + n\x20detached\n\x20from\x20its\x20topic.\n\n\x0f\n\x05\x04\n\x02\x01\x04\ + \x12\x06\xd8\x01\x02\xd3\x01\x12\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\xd8\ + \x01\x02\x08\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\xd8\x01\t\x0e\n\r\n\x05\ + \x04\n\x02\x01\x03\x12\x04\xd8\x01\x11\x12\n\xc7\x01\n\x04\x04\n\x02\x02\ + \x12\x04\xdd\x01\x02\x1d\x1a\xb8\x01\x20If\x20push\x20delivery\x20is\x20\ + used\x20with\x20this\x20subscription,\x20this\x20field\x20is\n\x20used\ + \x20to\x20configure\x20it.\x20An\x20empty\x20pushConfig\x20signifies\x20\ + that\x20the\x20subscriber\n\x20will\x20pull\x20and\x20ack\x20messages\ + \x20using\x20API\x20methods.\n\n\x0f\n\x05\x04\n\x02\x02\x04\x12\x06\xdd\ + \x01\x02\xd8\x01\x13\n\r\n\x05\x04\n\x02\x02\x06\x12\x04\xdd\x01\x02\x0c\ + \n\r\n\x05\x04\n\x02\x02\x01\x12\x04\xdd\x01\r\x18\n\r\n\x05\x04\n\x02\ + \x02\x03\x12\x04\xdd\x01\x1b\x1c\n\xd3\x05\n\x04\x04\n\x02\x03\x12\x04\ + \xee\x01\x02!\x1a\xc4\x05\x20This\x20value\x20is\x20the\x20maximum\x20ti\ + me\x20after\x20a\x20subscriber\x20receives\x20a\x20message\n\x20before\ + \x20the\x20subscriber\x20should\x20acknowledge\x20the\x20message.\x20Aft\ + er\x20message\n\x20delivery\x20but\x20before\x20the\x20ack\x20deadline\ + \x20expires\x20and\x20before\x20the\x20message\x20is\n\x20acknowledged,\ + \x20it\x20is\x20an\x20outstanding\x20message\x20and\x20will\x20not\x20be\ + \x20delivered\n\x20again\x20during\x20that\x20time\x20(on\x20a\x20best-e\ + ffort\x20basis).\n\n\x20For\x20pull\x20delivery\x20this\x20value\n\x20is\ + \x20used\x20as\x20the\x20initial\x20value\x20for\x20the\x20ack\x20deadli\ + ne.\x20It\x20may\x20be\x20overridden\n\x20for\x20a\x20specific\x20messag\ + e\x20by\x20calling\x20ModifyAckDeadline.\n\n\x20For\x20push\x20delivery,\ + \x20this\x20value\x20is\x20also\x20used\x20to\x20set\x20the\x20request\ + \x20timeout\x20for\n\x20the\x20call\x20to\x20the\x20push\x20endpoint.\n\ + \n\x20If\x20the\x20subscriber\x20never\x20acknowledges\x20the\x20message\ + ,\x20the\x20Pub/Sub\n\x20system\x20will\x20eventually\x20redeliver\x20th\ + e\x20message.\n\n\x0f\n\x05\x04\n\x02\x03\x04\x12\x06\xee\x01\x02\xdd\ + \x01\x1d\n\r\n\x05\x04\n\x02\x03\x05\x12\x04\xee\x01\x02\x07\n\r\n\x05\ + \x04\n\x02\x03\x01\x12\x04\xee\x01\x08\x1c\n\r\n\x05\x04\n\x02\x03\x03\ + \x12\x04\xee\x01\x1f\x20\n;\n\x02\x04\x0b\x12\x06\xf2\x01\0\x8f\x02\x01\ + \x1a-\x20Configuration\x20for\x20a\x20push\x20delivery\x20endpoint.\n\n\ + \x0b\n\x03\x04\x0b\x01\x12\x04\xf2\x01\x08\x12\n\x97\x01\n\x04\x04\x0b\ + \x02\0\x12\x04\xf5\x01\x02\x1b\x1a\x88\x01\x20A\x20URL\x20locating\x20th\ + e\x20endpoint\x20to\x20which\x20messages\x20should\x20be\x20pushed.\n\ + \x20For\x20example,\x20a\x20Webhook\x20endpoint\x20might\x20use\x20\"htt\ + ps://example.com/push\".\n\n\x0f\n\x05\x04\x0b\x02\0\x04\x12\x06\xf5\x01\ + \x02\xf2\x01\x14\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\xf5\x01\x02\x08\n\r\ + \n\x05\x04\x0b\x02\0\x01\x12\x04\xf5\x01\t\x16\n\r\n\x05\x04\x0b\x02\0\ + \x03\x12\x04\xf5\x01\x19\x1a\n\xfe\x07\n\x04\x04\x0b\x02\x01\x12\x04\x8e\ + \x02\x02%\x1a\xef\x07\x20Endpoint\x20configuration\x20attributes.\n\n\ + \x20Every\x20endpoint\x20has\x20a\x20set\x20of\x20API\x20supported\x20at\ + tributes\x20that\x20can\x20be\x20used\x20to\n\x20control\x20different\ + \x20aspects\x20of\x20the\x20message\x20delivery.\n\n\x20The\x20currently\ + \x20supported\x20attribute\x20is\x20`x-goog-version`,\x20which\x20you\ + \x20can\n\x20use\x20to\x20change\x20the\x20format\x20of\x20the\x20push\ + \x20message.\x20This\x20attribute\n\x20indicates\x20the\x20version\x20of\ + \x20the\x20data\x20expected\x20by\x20the\x20endpoint.\x20This\n\x20contr\ + ols\x20the\x20shape\x20of\x20the\x20envelope\x20(i.e.\x20its\x20fields\ + \x20and\x20metadata).\n\x20The\x20endpoint\x20version\x20is\x20based\x20\ + on\x20the\x20version\x20of\x20the\x20Pub/Sub\n\x20API.\n\n\x20If\x20not\ + \x20present\x20during\x20the\x20CreateSubscription\x20call,\x20it\x20wil\ + l\x20default\x20to\n\x20the\x20version\x20of\x20the\x20API\x20used\x20to\ + \x20make\x20such\x20call.\x20If\x20not\x20present\x20during\x20a\n\x20Mo\ + difyPushConfig\x20call,\x20its\x20value\x20will\x20not\x20be\x20changed.\ + \x20GetSubscription\n\x20calls\x20will\x20always\x20return\x20a\x20valid\ + \x20version,\x20even\x20if\x20the\x20subscription\x20was\n\x20created\ + \x20without\x20this\x20attribute.\n\n\x20The\x20possible\x20values\x20fo\ + r\x20this\x20attribute\x20are:\n\n\x20*\x20`v1beta1`:\x20uses\x20the\x20\ + push\x20format\x20defined\x20in\x20the\x20v1beta1\x20Pub/Sub\x20API.\n\ + \x20*\x20`v1beta2`:\x20uses\x20the\x20push\x20format\x20defined\x20in\ + \x20the\x20v1beta2\x20Pub/Sub\x20API.\n\n\n\x0f\n\x05\x04\x0b\x02\x01\ + \x04\x12\x06\x8e\x02\x02\xf5\x01\x1b\n\r\n\x05\x04\x0b\x02\x01\x06\x12\ + \x04\x8e\x02\x02\x15\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\x8e\x02\x16\ + \x20\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\x8e\x02#$\nB\n\x02\x04\x0c\ + \x12\x06\x92\x02\0\x98\x02\x01\x1a4\x20A\x20message\x20and\x20its\x20cor\ + responding\x20acknowledgment\x20ID.\n\n\x0b\n\x03\x04\x0c\x01\x12\x04\ + \x92\x02\x08\x17\nH\n\x04\x04\x0c\x02\0\x12\x04\x94\x02\x02\x14\x1a:\x20\ + This\x20ID\x20can\x20be\x20used\x20to\x20acknowledge\x20the\x20received\ + \x20message.\n\n\x0f\n\x05\x04\x0c\x02\0\x04\x12\x06\x94\x02\x02\x92\x02\ + \x19\n\r\n\x05\x04\x0c\x02\0\x05\x12\x04\x94\x02\x02\x08\n\r\n\x05\x04\ + \x0c\x02\0\x01\x12\x04\x94\x02\t\x0f\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\ + \x94\x02\x12\x13\n\x1c\n\x04\x04\x0c\x02\x01\x12\x04\x97\x02\x02\x1c\x1a\ + \x0e\x20The\x20message.\n\n\x0f\n\x05\x04\x0c\x02\x01\x04\x12\x06\x97\ + \x02\x02\x94\x02\x14\n\r\n\x05\x04\x0c\x02\x01\x06\x12\x04\x97\x02\x02\ + \x0f\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\x97\x02\x10\x17\n\r\n\x05\x04\ + \x0c\x02\x01\x03\x12\x04\x97\x02\x1a\x1b\n7\n\x02\x04\r\x12\x06\x9b\x02\ + \0\x9e\x02\x01\x1a)\x20Request\x20for\x20the\x20GetSubscription\x20metho\ + d.\n\n\x0b\n\x03\x04\r\x01\x12\x04\x9b\x02\x08\x1e\n4\n\x04\x04\r\x02\0\ + \x12\x04\x9d\x02\x02\x1a\x1a&\x20The\x20name\x20of\x20the\x20subscriptio\ + n\x20to\x20get.\n\n\x0f\n\x05\x04\r\x02\0\x04\x12\x06\x9d\x02\x02\x9b\ + \x02\x20\n\r\n\x05\x04\r\x02\0\x05\x12\x04\x9d\x02\x02\x08\n\r\n\x05\x04\ + \r\x02\0\x01\x12\x04\x9d\x02\t\x15\n\r\n\x05\x04\r\x02\0\x03\x12\x04\x9d\ + \x02\x18\x19\n9\n\x02\x04\x0e\x12\x06\xa1\x02\0\xac\x02\x01\x1a+\x20Requ\ + est\x20for\x20the\x20ListSubscriptions\x20method.\n\n\x0b\n\x03\x04\x0e\ + \x01\x12\x04\xa1\x02\x08\x20\nK\n\x04\x04\x0e\x02\0\x12\x04\xa3\x02\x02\ + \x15\x1a=\x20The\x20name\x20of\x20the\x20cloud\x20project\x20that\x20sub\ + scriptions\x20belong\x20to.\n\n\x0f\n\x05\x04\x0e\x02\0\x04\x12\x06\xa3\ + \x02\x02\xa1\x02\"\n\r\n\x05\x04\x0e\x02\0\x05\x12\x04\xa3\x02\x02\x08\n\ + \r\n\x05\x04\x0e\x02\0\x01\x12\x04\xa3\x02\t\x10\n\r\n\x05\x04\x0e\x02\0\ + \x03\x12\x04\xa3\x02\x13\x14\n:\n\x04\x04\x0e\x02\x01\x12\x04\xa6\x02\ + \x02\x16\x1a,\x20Maximum\x20number\x20of\x20subscriptions\x20to\x20retur\ + n.\n\n\x0f\n\x05\x04\x0e\x02\x01\x04\x12\x06\xa6\x02\x02\xa3\x02\x15\n\r\ + \n\x05\x04\x0e\x02\x01\x05\x12\x04\xa6\x02\x02\x07\n\r\n\x05\x04\x0e\x02\ + \x01\x01\x12\x04\xa6\x02\x08\x11\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\ + \xa6\x02\x14\x15\n\xce\x01\n\x04\x04\x0e\x02\x02\x12\x04\xab\x02\x02\x18\ + \x1a\xbf\x01\x20The\x20value\x20returned\x20by\x20the\x20last\x20ListSub\ + scriptionsResponse;\x20indicates\x20that\n\x20this\x20is\x20a\x20continu\ + ation\x20of\x20a\x20prior\x20ListSubscriptions\x20call,\x20and\x20that\ + \x20the\n\x20system\x20should\x20return\x20the\x20next\x20page\x20of\x20\ + data.\n\n\x0f\n\x05\x04\x0e\x02\x02\x04\x12\x06\xab\x02\x02\xa6\x02\x16\ + \n\r\n\x05\x04\x0e\x02\x02\x05\x12\x04\xab\x02\x02\x08\n\r\n\x05\x04\x0e\ + \x02\x02\x01\x12\x04\xab\x02\t\x13\n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\ + \xab\x02\x16\x17\n:\n\x02\x04\x0f\x12\x06\xaf\x02\0\xb7\x02\x01\x1a,\x20\ + Response\x20for\x20the\x20ListSubscriptions\x20method.\n\n\x0b\n\x03\x04\ + \x0f\x01\x12\x04\xaf\x02\x08!\n9\n\x04\x04\x0f\x02\0\x12\x04\xb1\x02\x02\ + *\x1a+\x20The\x20subscriptions\x20that\x20match\x20the\x20request.\n\n\r\ + \n\x05\x04\x0f\x02\0\x04\x12\x04\xb1\x02\x02\n\n\r\n\x05\x04\x0f\x02\0\ + \x06\x12\x04\xb1\x02\x0b\x17\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\xb1\x02\ + \x18%\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xb1\x02()\n\xc0\x01\n\x04\x04\ + \x0f\x02\x01\x12\x04\xb6\x02\x02\x1d\x1a\xb1\x01\x20If\x20not\x20empty,\ + \x20indicates\x20that\x20there\x20may\x20be\x20more\x20subscriptions\x20\ + that\x20match\n\x20the\x20request;\x20this\x20value\x20should\x20be\x20p\ + assed\x20in\x20a\x20new\x20ListSubscriptionsRequest\n\x20to\x20get\x20mo\ + re\x20subscriptions.\n\n\x0f\n\x05\x04\x0f\x02\x01\x04\x12\x06\xb6\x02\ + \x02\xb1\x02*\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\xb6\x02\x02\x08\n\r\ + \n\x05\x04\x0f\x02\x01\x01\x12\x04\xb6\x02\t\x18\n\r\n\x05\x04\x0f\x02\ + \x01\x03\x12\x04\xb6\x02\x1b\x1c\n:\n\x02\x04\x10\x12\x06\xba\x02\0\xbd\ + \x02\x01\x1a,\x20Request\x20for\x20the\x20DeleteSubscription\x20method.\ + \n\n\x0b\n\x03\x04\x10\x01\x12\x04\xba\x02\x08!\n+\n\x04\x04\x10\x02\0\ + \x12\x04\xbc\x02\x02\x1a\x1a\x1d\x20The\x20subscription\x20to\x20delete.\ + \n\n\x0f\n\x05\x04\x10\x02\0\x04\x12\x06\xbc\x02\x02\xba\x02#\n\r\n\x05\ + \x04\x10\x02\0\x05\x12\x04\xbc\x02\x02\x08\n\r\n\x05\x04\x10\x02\0\x01\ + \x12\x04\xbc\x02\t\x15\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\xbc\x02\x18\ + \x19\n8\n\x02\x04\x11\x12\x06\xc0\x02\0\xcb\x02\x01\x1a*\x20Request\x20f\ + or\x20the\x20ModifyPushConfig\x20method.\n\n\x0b\n\x03\x04\x11\x01\x12\ + \x04\xc0\x02\x08\x1f\n-\n\x04\x04\x11\x02\0\x12\x04\xc2\x02\x02\x1a\x1a\ + \x1f\x20The\x20name\x20of\x20the\x20subscription.\n\n\x0f\n\x05\x04\x11\ + \x02\0\x04\x12\x06\xc2\x02\x02\xc0\x02!\n\r\n\x05\x04\x11\x02\0\x05\x12\ + \x04\xc2\x02\x02\x08\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\xc2\x02\t\x15\n\ + \r\n\x05\x04\x11\x02\0\x03\x12\x04\xc2\x02\x18\x19\n\xa1\x02\n\x04\x04\ + \x11\x02\x01\x12\x04\xca\x02\x02\x1d\x1a\x92\x02\x20The\x20push\x20confi\ + guration\x20for\x20future\x20deliveries.\n\n\x20An\x20empty\x20pushConfi\ + g\x20indicates\x20that\x20the\x20Pub/Sub\x20system\x20should\n\x20stop\ + \x20pushing\x20messages\x20from\x20the\x20given\x20subscription\x20and\ + \x20allow\n\x20messages\x20to\x20be\x20pulled\x20and\x20acknowledged\x20\ + -\x20effectively\x20pausing\n\x20the\x20subscription\x20if\x20Pull\x20is\ + \x20not\x20called.\n\n\x0f\n\x05\x04\x11\x02\x01\x04\x12\x06\xca\x02\x02\ + \xc2\x02\x1a\n\r\n\x05\x04\x11\x02\x01\x06\x12\x04\xca\x02\x02\x0c\n\r\n\ + \x05\x04\x11\x02\x01\x01\x12\x04\xca\x02\r\x18\n\r\n\x05\x04\x11\x02\x01\ + \x03\x12\x04\xca\x02\x1b\x1c\n,\n\x02\x04\x12\x12\x06\xce\x02\0\xdc\x02\ + \x01\x1a\x1e\x20Request\x20for\x20the\x20Pull\x20method.\n\n\x0b\n\x03\ + \x04\x12\x01\x12\x04\xce\x02\x08\x13\nF\n\x04\x04\x12\x02\0\x12\x04\xd0\ + \x02\x02\x1a\x1a8\x20The\x20subscription\x20from\x20which\x20messages\ + \x20should\x20be\x20pulled.\n\n\x0f\n\x05\x04\x12\x02\0\x04\x12\x06\xd0\ + \x02\x02\xce\x02\x15\n\r\n\x05\x04\x12\x02\0\x05\x12\x04\xd0\x02\x02\x08\ + \n\r\n\x05\x04\x12\x02\0\x01\x12\x04\xd0\x02\t\x15\n\r\n\x05\x04\x12\x02\ + \0\x03\x12\x04\xd0\x02\x18\x19\n\xe4\x02\n\x04\x04\x12\x02\x01\x12\x04\ + \xd7\x02\x02\x1e\x1a\xd5\x02\x20If\x20this\x20is\x20specified\x20as\x20t\ + rue\x20the\x20system\x20will\x20respond\x20immediately\x20even\x20if\n\ + \x20it\x20is\x20not\x20able\x20to\x20return\x20a\x20message\x20in\x20the\ + \x20Pull\x20response.\x20Otherwise\x20the\n\x20system\x20is\x20allowed\ + \x20to\x20wait\x20until\x20at\x20least\x20one\x20message\x20is\x20availa\ + ble\x20rather\n\x20than\x20returning\x20no\x20messages.\x20The\x20client\ + \x20may\x20cancel\x20the\x20request\x20if\x20it\x20does\n\x20not\x20wish\ + \x20to\x20wait\x20any\x20longer\x20for\x20the\x20response.\n\n\x0f\n\x05\ + \x04\x12\x02\x01\x04\x12\x06\xd7\x02\x02\xd0\x02\x1a\n\r\n\x05\x04\x12\ + \x02\x01\x05\x12\x04\xd7\x02\x02\x06\n\r\n\x05\x04\x12\x02\x01\x01\x12\ + \x04\xd7\x02\x07\x19\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\xd7\x02\x1c\ + \x1d\n\x89\x01\n\x04\x04\x12\x02\x02\x12\x04\xdb\x02\x02\x19\x1a{\x20The\ + \x20maximum\x20number\x20of\x20messages\x20returned\x20for\x20this\x20re\ + quest.\x20The\x20Pub/Sub\n\x20system\x20may\x20return\x20fewer\x20than\ + \x20the\x20number\x20specified.\n\n\x0f\n\x05\x04\x12\x02\x02\x04\x12\ + \x06\xdb\x02\x02\xd7\x02\x1e\n\r\n\x05\x04\x12\x02\x02\x05\x12\x04\xdb\ + \x02\x02\x07\n\r\n\x05\x04\x12\x02\x02\x01\x12\x04\xdb\x02\x08\x14\n\r\n\ + \x05\x04\x12\x02\x02\x03\x12\x04\xdb\x02\x17\x18\n-\n\x02\x04\x13\x12\ + \x06\xdf\x02\0\xe5\x02\x01\x1a\x1f\x20Response\x20for\x20the\x20Pull\x20\ + method.\n\n\x0b\n\x03\x04\x13\x01\x12\x04\xdf\x02\x08\x14\n\x87\x02\n\ + \x04\x04\x13\x02\0\x12\x04\xe4\x02\x021\x1a\xf8\x01\x20Received\x20Pub/S\ + ub\x20messages.\x20The\x20Pub/Sub\x20system\x20will\x20return\x20zero\ + \x20messages\x20if\n\x20there\x20are\x20no\x20more\x20available\x20in\ + \x20the\x20backlog.\x20The\x20Pub/Sub\x20system\x20may\x20return\n\x20fe\ + wer\x20than\x20the\x20maxMessages\x20requested\x20even\x20if\x20there\ + \x20are\x20more\x20messages\n\x20available\x20in\x20the\x20backlog.\n\n\ + \r\n\x05\x04\x13\x02\0\x04\x12\x04\xe4\x02\x02\n\n\r\n\x05\x04\x13\x02\0\ + \x06\x12\x04\xe4\x02\x0b\x1a\n\r\n\x05\x04\x13\x02\0\x01\x12\x04\xe4\x02\ + \x1b,\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\xe4\x02/0\n9\n\x02\x04\x14\x12\ + \x06\xe8\x02\0\xf5\x02\x01\x1a+\x20Request\x20for\x20the\x20ModifyAckDea\ + dline\x20method.\n\n\x0b\n\x03\x04\x14\x01\x12\x04\xe8\x02\x08\x20\n-\n\ + \x04\x04\x14\x02\0\x12\x04\xea\x02\x02\x1a\x1a\x1f\x20The\x20name\x20of\ + \x20the\x20subscription.\n\n\x0f\n\x05\x04\x14\x02\0\x04\x12\x06\xea\x02\ + \x02\xe8\x02\"\n\r\n\x05\x04\x14\x02\0\x05\x12\x04\xea\x02\x02\x08\n\r\n\ + \x05\x04\x14\x02\0\x01\x12\x04\xea\x02\t\x15\n\r\n\x05\x04\x14\x02\0\x03\ + \x12\x04\xea\x02\x18\x19\n&\n\x04\x04\x14\x02\x01\x12\x04\xed\x02\x02\ + \x14\x1a\x18\x20The\x20acknowledgment\x20ID.\n\n\x0f\n\x05\x04\x14\x02\ + \x01\x04\x12\x06\xed\x02\x02\xea\x02\x1a\n\r\n\x05\x04\x14\x02\x01\x05\ + \x12\x04\xed\x02\x02\x08\n\r\n\x05\x04\x14\x02\x01\x01\x12\x04\xed\x02\t\ + \x0f\n\r\n\x05\x04\x14\x02\x01\x03\x12\x04\xed\x02\x12\x13\n\xca\x02\n\ + \x04\x04\x14\x02\x02\x12\x04\xf4\x02\x02!\x1a\xbb\x02\x20The\x20new\x20a\ + ck\x20deadline\x20with\x20respect\x20to\x20the\x20time\x20this\x20reques\ + t\x20was\x20sent\x20to\x20the\n\x20Pub/Sub\x20system.\x20Must\x20be\x20>\ + =\x200.\x20For\x20example,\x20if\x20the\x20value\x20is\x2010,\x20the\x20\ + new\x20ack\n\x20deadline\x20will\x20expire\x2010\x20seconds\x20after\x20\ + the\x20ModifyAckDeadline\x20call\x20was\x20made.\n\x20Specifying\x20zero\ + \x20may\x20immediately\x20make\x20the\x20message\x20available\x20for\x20\ + another\x20pull\n\x20request.\n\n\x0f\n\x05\x04\x14\x02\x02\x04\x12\x06\ + \xf4\x02\x02\xed\x02\x14\n\r\n\x05\x04\x14\x02\x02\x05\x12\x04\xf4\x02\ + \x02\x07\n\r\n\x05\x04\x14\x02\x02\x01\x12\x04\xf4\x02\x08\x1c\n\r\n\x05\ + \x04\x14\x02\x02\x03\x12\x04\xf4\x02\x1f\x20\n3\n\x02\x04\x15\x12\x06\ + \xf8\x02\0\xff\x02\x01\x1a%\x20Request\x20for\x20the\x20Acknowledge\x20m\ + ethod.\n\n\x0b\n\x03\x04\x15\x01\x12\x04\xf8\x02\x08\x1a\nE\n\x04\x04\ + \x15\x02\0\x12\x04\xfa\x02\x02\x1a\x1a7\x20The\x20subscription\x20whose\ + \x20message\x20is\x20being\x20acknowledged.\n\n\x0f\n\x05\x04\x15\x02\0\ + \x04\x12\x06\xfa\x02\x02\xf8\x02\x1c\n\r\n\x05\x04\x15\x02\0\x05\x12\x04\ + \xfa\x02\x02\x08\n\r\n\x05\x04\x15\x02\0\x01\x12\x04\xfa\x02\t\x15\n\r\n\ + \x05\x04\x15\x02\0\x03\x12\x04\xfa\x02\x18\x19\n\x9c\x01\n\x04\x04\x15\ + \x02\x01\x12\x04\xfe\x02\x02\x1e\x1a\x8d\x01\x20The\x20acknowledgment\ + \x20ID\x20for\x20the\x20messages\x20being\x20acknowledged\x20that\x20was\ + \x20returned\n\x20by\x20the\x20Pub/Sub\x20system\x20in\x20the\x20Pull\ + \x20response.\x20Must\x20not\x20be\x20empty.\n\n\r\n\x05\x04\x15\x02\x01\ + \x04\x12\x04\xfe\x02\x02\n\n\r\n\x05\x04\x15\x02\x01\x05\x12\x04\xfe\x02\ + \x0b\x11\n\r\n\x05\x04\x15\x02\x01\x01\x12\x04\xfe\x02\x12\x19\n\r\n\x05\ + \x04\x15\x02\x01\x03\x12\x04\xfe\x02\x1c\x1db\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub_grpc.rs new file mode 100644 index 00000000..50efd97b --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/pubsub/v1beta2/pubsub_grpc.rs @@ -0,0 +1,459 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/CreateSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_GET_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/GetSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/ListSubscriptions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/DeleteSubscription", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/ModifyAckDeadline", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_ACKNOWLEDGE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/Acknowledge", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_PULL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/Pull", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Subscriber/ModifyPushConfig", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct SubscriberClient { + client: ::grpcio::Client, +} + +impl SubscriberClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + SubscriberClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_subscription_opt(&self, req: &super::pubsub::Subscription, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, req, opt) + } + + pub fn create_subscription(&self, req: &super::pubsub::Subscription) -> ::grpcio::Result { + self.create_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_subscription_async_opt(&self, req: &super::pubsub::Subscription, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, req, opt) + } + + pub fn create_subscription_async(&self, req: &super::pubsub::Subscription) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_subscription_opt(&self, req: &super::pubsub::GetSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, req, opt) + } + + pub fn get_subscription(&self, req: &super::pubsub::GetSubscriptionRequest) -> ::grpcio::Result { + self.get_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_subscription_async_opt(&self, req: &super::pubsub::GetSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, req, opt) + } + + pub fn get_subscription_async(&self, req: &super::pubsub::GetSubscriptionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_subscriptions_opt(&self, req: &super::pubsub::ListSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, req, opt) + } + + pub fn list_subscriptions(&self, req: &super::pubsub::ListSubscriptionsRequest) -> ::grpcio::Result { + self.list_subscriptions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_subscriptions_async_opt(&self, req: &super::pubsub::ListSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, req, opt) + } + + pub fn list_subscriptions_async(&self, req: &super::pubsub::ListSubscriptionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_subscriptions_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_subscription_opt(&self, req: &super::pubsub::DeleteSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, req, opt) + } + + pub fn delete_subscription(&self, req: &super::pubsub::DeleteSubscriptionRequest) -> ::grpcio::Result { + self.delete_subscription_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_subscription_async_opt(&self, req: &super::pubsub::DeleteSubscriptionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, req, opt) + } + + pub fn delete_subscription_async(&self, req: &super::pubsub::DeleteSubscriptionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_subscription_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_ack_deadline_opt(&self, req: &super::pubsub::ModifyAckDeadlineRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, req, opt) + } + + pub fn modify_ack_deadline(&self, req: &super::pubsub::ModifyAckDeadlineRequest) -> ::grpcio::Result { + self.modify_ack_deadline_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_ack_deadline_async_opt(&self, req: &super::pubsub::ModifyAckDeadlineRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, req, opt) + } + + pub fn modify_ack_deadline_async(&self, req: &super::pubsub::ModifyAckDeadlineRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.modify_ack_deadline_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn acknowledge_opt(&self, req: &super::pubsub::AcknowledgeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_ACKNOWLEDGE, req, opt) + } + + pub fn acknowledge(&self, req: &super::pubsub::AcknowledgeRequest) -> ::grpcio::Result { + self.acknowledge_opt(req, ::grpcio::CallOption::default()) + } + + pub fn acknowledge_async_opt(&self, req: &super::pubsub::AcknowledgeRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_ACKNOWLEDGE, req, opt) + } + + pub fn acknowledge_async(&self, req: &super::pubsub::AcknowledgeRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.acknowledge_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn pull_opt(&self, req: &super::pubsub::PullRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_PULL, req, opt) + } + + pub fn pull(&self, req: &super::pubsub::PullRequest) -> ::grpcio::Result { + self.pull_opt(req, ::grpcio::CallOption::default()) + } + + pub fn pull_async_opt(&self, req: &super::pubsub::PullRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_PULL, req, opt) + } + + pub fn pull_async(&self, req: &super::pubsub::PullRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.pull_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_push_config_opt(&self, req: &super::pubsub::ModifyPushConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, req, opt) + } + + pub fn modify_push_config(&self, req: &super::pubsub::ModifyPushConfigRequest) -> ::grpcio::Result { + self.modify_push_config_opt(req, ::grpcio::CallOption::default()) + } + + pub fn modify_push_config_async_opt(&self, req: &super::pubsub::ModifyPushConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, req, opt) + } + + pub fn modify_push_config_async(&self, req: &super::pubsub::ModifyPushConfigRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.modify_push_config_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Subscriber { + fn create_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::Subscription, sink: ::grpcio::UnarySink); + fn get_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::GetSubscriptionRequest, sink: ::grpcio::UnarySink); + fn list_subscriptions(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListSubscriptionsRequest, sink: ::grpcio::UnarySink); + fn delete_subscription(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::DeleteSubscriptionRequest, sink: ::grpcio::UnarySink); + fn modify_ack_deadline(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ModifyAckDeadlineRequest, sink: ::grpcio::UnarySink); + fn acknowledge(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::AcknowledgeRequest, sink: ::grpcio::UnarySink); + fn pull(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::PullRequest, sink: ::grpcio::UnarySink); + fn modify_push_config(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ModifyPushConfigRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_subscriber(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_CREATE_SUBSCRIPTION, move |ctx, req, resp| { + instance.create_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_GET_SUBSCRIPTION, move |ctx, req, resp| { + instance.get_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_LIST_SUBSCRIPTIONS, move |ctx, req, resp| { + instance.list_subscriptions(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_DELETE_SUBSCRIPTION, move |ctx, req, resp| { + instance.delete_subscription(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_MODIFY_ACK_DEADLINE, move |ctx, req, resp| { + instance.modify_ack_deadline(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_ACKNOWLEDGE, move |ctx, req, resp| { + instance.acknowledge(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_PULL, move |ctx, req, resp| { + instance.pull(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SUBSCRIBER_MODIFY_PUSH_CONFIG, move |ctx, req, resp| { + instance.modify_push_config(ctx, req, resp) + }); + builder.build() +} + +const METHOD_PUBLISHER_CREATE_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/CreateTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_PUBLISH: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/Publish", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_GET_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/GetTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_LIST_TOPICS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/ListTopics", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/ListTopicSubscriptions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_PUBLISHER_DELETE_TOPIC: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.pubsub.v1beta2.Publisher/DeleteTopic", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct PublisherClient { + client: ::grpcio::Client, +} + +impl PublisherClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + PublisherClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_topic_opt(&self, req: &super::pubsub::Topic, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_CREATE_TOPIC, req, opt) + } + + pub fn create_topic(&self, req: &super::pubsub::Topic) -> ::grpcio::Result { + self.create_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_topic_async_opt(&self, req: &super::pubsub::Topic, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_CREATE_TOPIC, req, opt) + } + + pub fn create_topic_async(&self, req: &super::pubsub::Topic) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_topic_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn publish_opt(&self, req: &super::pubsub::PublishRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_PUBLISH, req, opt) + } + + pub fn publish(&self, req: &super::pubsub::PublishRequest) -> ::grpcio::Result { + self.publish_opt(req, ::grpcio::CallOption::default()) + } + + pub fn publish_async_opt(&self, req: &super::pubsub::PublishRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_PUBLISH, req, opt) + } + + pub fn publish_async(&self, req: &super::pubsub::PublishRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.publish_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_topic_opt(&self, req: &super::pubsub::GetTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_GET_TOPIC, req, opt) + } + + pub fn get_topic(&self, req: &super::pubsub::GetTopicRequest) -> ::grpcio::Result { + self.get_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_topic_async_opt(&self, req: &super::pubsub::GetTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_GET_TOPIC, req, opt) + } + + pub fn get_topic_async(&self, req: &super::pubsub::GetTopicRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_topic_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topics_opt(&self, req: &super::pubsub::ListTopicsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_LIST_TOPICS, req, opt) + } + + pub fn list_topics(&self, req: &super::pubsub::ListTopicsRequest) -> ::grpcio::Result { + self.list_topics_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topics_async_opt(&self, req: &super::pubsub::ListTopicsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_LIST_TOPICS, req, opt) + } + + pub fn list_topics_async(&self, req: &super::pubsub::ListTopicsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_topics_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_subscriptions_opt(&self, req: &super::pubsub::ListTopicSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, req, opt) + } + + pub fn list_topic_subscriptions(&self, req: &super::pubsub::ListTopicSubscriptionsRequest) -> ::grpcio::Result { + self.list_topic_subscriptions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_topic_subscriptions_async_opt(&self, req: &super::pubsub::ListTopicSubscriptionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, req, opt) + } + + pub fn list_topic_subscriptions_async(&self, req: &super::pubsub::ListTopicSubscriptionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_topic_subscriptions_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_topic_opt(&self, req: &super::pubsub::DeleteTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_PUBLISHER_DELETE_TOPIC, req, opt) + } + + pub fn delete_topic(&self, req: &super::pubsub::DeleteTopicRequest) -> ::grpcio::Result { + self.delete_topic_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_topic_async_opt(&self, req: &super::pubsub::DeleteTopicRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_PUBLISHER_DELETE_TOPIC, req, opt) + } + + pub fn delete_topic_async(&self, req: &super::pubsub::DeleteTopicRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_topic_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Publisher { + fn create_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::Topic, sink: ::grpcio::UnarySink); + fn publish(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::PublishRequest, sink: ::grpcio::UnarySink); + fn get_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::GetTopicRequest, sink: ::grpcio::UnarySink); + fn list_topics(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListTopicsRequest, sink: ::grpcio::UnarySink); + fn list_topic_subscriptions(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::ListTopicSubscriptionsRequest, sink: ::grpcio::UnarySink); + fn delete_topic(&mut self, ctx: ::grpcio::RpcContext, req: super::pubsub::DeleteTopicRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_publisher(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_CREATE_TOPIC, move |ctx, req, resp| { + instance.create_topic(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_PUBLISH, move |ctx, req, resp| { + instance.publish(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_GET_TOPIC, move |ctx, req, resp| { + instance.get_topic(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_LIST_TOPICS, move |ctx, req, resp| { + instance.list_topics(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_LIST_TOPIC_SUBSCRIPTIONS, move |ctx, req, resp| { + instance.list_topic_subscriptions(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_PUBLISHER_DELETE_TOPIC, move |ctx, req, resp| { + instance.delete_topic(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/code.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/code.rs new file mode 100644 index 00000000..f764a689 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/code.rs @@ -0,0 +1,325 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/rpc/code.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Code { + OK = 0, + CANCELLED = 1, + UNKNOWN = 2, + INVALID_ARGUMENT = 3, + DEADLINE_EXCEEDED = 4, + NOT_FOUND = 5, + ALREADY_EXISTS = 6, + PERMISSION_DENIED = 7, + UNAUTHENTICATED = 16, + RESOURCE_EXHAUSTED = 8, + FAILED_PRECONDITION = 9, + ABORTED = 10, + OUT_OF_RANGE = 11, + UNIMPLEMENTED = 12, + INTERNAL = 13, + UNAVAILABLE = 14, + DATA_LOSS = 15, +} + +impl ::protobuf::ProtobufEnum for Code { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Code::OK), + 1 => ::std::option::Option::Some(Code::CANCELLED), + 2 => ::std::option::Option::Some(Code::UNKNOWN), + 3 => ::std::option::Option::Some(Code::INVALID_ARGUMENT), + 4 => ::std::option::Option::Some(Code::DEADLINE_EXCEEDED), + 5 => ::std::option::Option::Some(Code::NOT_FOUND), + 6 => ::std::option::Option::Some(Code::ALREADY_EXISTS), + 7 => ::std::option::Option::Some(Code::PERMISSION_DENIED), + 16 => ::std::option::Option::Some(Code::UNAUTHENTICATED), + 8 => ::std::option::Option::Some(Code::RESOURCE_EXHAUSTED), + 9 => ::std::option::Option::Some(Code::FAILED_PRECONDITION), + 10 => ::std::option::Option::Some(Code::ABORTED), + 11 => ::std::option::Option::Some(Code::OUT_OF_RANGE), + 12 => ::std::option::Option::Some(Code::UNIMPLEMENTED), + 13 => ::std::option::Option::Some(Code::INTERNAL), + 14 => ::std::option::Option::Some(Code::UNAVAILABLE), + 15 => ::std::option::Option::Some(Code::DATA_LOSS), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Code] = &[ + Code::OK, + Code::CANCELLED, + Code::UNKNOWN, + Code::INVALID_ARGUMENT, + Code::DEADLINE_EXCEEDED, + Code::NOT_FOUND, + Code::ALREADY_EXISTS, + Code::PERMISSION_DENIED, + Code::UNAUTHENTICATED, + Code::RESOURCE_EXHAUSTED, + Code::FAILED_PRECONDITION, + Code::ABORTED, + Code::OUT_OF_RANGE, + Code::UNIMPLEMENTED, + Code::INTERNAL, + Code::UNAVAILABLE, + Code::DATA_LOSS, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Code", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Code { +} + +impl ::std::default::Default for Code { + fn default() -> Self { + Code::OK + } +} + +impl ::protobuf::reflect::ProtobufValue for Code { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x15google/rpc/code.proto\x12\ngoogle.rpc*\xb7\x02\n\x04Code\x12\x06\n\ + \x02OK\x10\0\x12\r\n\tCANCELLED\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\ + \x14\n\x10INVALID_ARGUMENT\x10\x03\x12\x15\n\x11DEADLINE_EXCEEDED\x10\ + \x04\x12\r\n\tNOT_FOUND\x10\x05\x12\x12\n\x0eALREADY_EXISTS\x10\x06\x12\ + \x15\n\x11PERMISSION_DENIED\x10\x07\x12\x13\n\x0fUNAUTHENTICATED\x10\x10\ + \x12\x16\n\x12RESOURCE_EXHAUSTED\x10\x08\x12\x17\n\x13FAILED_PRECONDITIO\ + N\x10\t\x12\x0b\n\x07ABORTED\x10\n\x12\x10\n\x0cOUT_OF_RANGE\x10\x0b\x12\ + \x11\n\rUNIMPLEMENTED\x10\x0c\x12\x0c\n\x08INTERNAL\x10\r\x12\x0f\n\x0bU\ + NAVAILABLE\x10\x0e\x12\r\n\tDATA_LOSS\x10\x0fBX\n\x0ecom.google.rpcB\tCo\ + deProtoP\x01Z3google.golang.org/genproto/googleapis/rpc/code;code\xa2\ + \x02\x03RPCJ\xb45\n\x07\x12\x05\x0e\0\xb9\x01\x01\n\xbd\x04\n\x01\x0c\ + \x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202017\x20Google\x20Inc.\n\n\ + \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\ + (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\ + xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\ + obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\ + \x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\ + \x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20s\ + oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\ + \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\ + \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\ + ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\ + governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\ + nse.\n\n\x08\n\x01\x02\x12\x03\x10\0\x13\n\x08\n\x01\x08\x12\x03\x12\0J\ + \n\t\n\x02\x08\x0b\x12\x03\x12\0J\n\x08\n\x01\x08\x12\x03\x13\0\"\n\t\n\ + \x02\x08\n\x12\x03\x13\0\"\n\x08\n\x01\x08\x12\x03\x14\0*\n\t\n\x02\x08\ + \x08\x12\x03\x14\0*\n\x08\n\x01\x08\x12\x03\x15\0'\n\t\n\x02\x08\x01\x12\ + \x03\x15\0'\n\x08\n\x01\x08\x12\x03\x16\0!\n\t\n\x02\x08$\x12\x03\x16\0!\ + \n\xce\x02\n\x02\x05\0\x12\x05\x20\0\xb9\x01\x01\x1a\xc0\x02\x20The\x20c\ + anonical\x20error\x20codes\x20for\x20Google\x20APIs.\n\n\n\x20Sometimes\ + \x20multiple\x20error\x20codes\x20may\x20apply.\x20\x20Services\x20shoul\ + d\x20return\n\x20the\x20most\x20specific\x20error\x20code\x20that\x20app\ + lies.\x20\x20For\x20example,\x20prefer\n\x20`OUT_OF_RANGE`\x20over\x20`F\ + AILED_PRECONDITION`\x20if\x20both\x20codes\x20apply.\n\x20Similarly\x20p\ + refer\x20`NOT_FOUND`\x20or\x20`ALREADY_EXISTS`\x20over\x20`FAILED_PRECON\ + DITION`.\n\n\n\n\x03\x05\0\x01\x12\x03\x20\x05\t\nG\n\x04\x05\0\x02\0\ + \x12\x03$\x02\t\x1a:\x20Not\x20an\x20error;\x20returned\x20on\x20success\ + \n\n\x20HTTP\x20Mapping:\x20200\x20OK\n\n\x0c\n\x05\x05\0\x02\0\x01\x12\ + \x03$\x02\x04\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03$\x07\x08\nn\n\x04\x05\ + \0\x02\x01\x12\x03)\x02\x10\x1aa\x20The\x20operation\x20was\x20cancelled\ + ,\x20typically\x20by\x20the\x20caller.\n\n\x20HTTP\x20Mapping:\x20499\ + \x20Client\x20Closed\x20Request\n\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03)\ + \x02\x0b\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03)\x0e\x0f\n\xda\x02\n\x04\ + \x05\0\x02\x02\x12\x032\x02\x0e\x1a\xcc\x02\x20Unknown\x20error.\x20\x20\ + For\x20example,\x20this\x20error\x20may\x20be\x20returned\x20when\n\x20a\ + \x20`Status`\x20value\x20received\x20from\x20another\x20address\x20space\ + \x20belongs\x20to\n\x20an\x20error\x20space\x20that\x20is\x20not\x20know\ + n\x20in\x20this\x20address\x20space.\x20\x20Also\n\x20errors\x20raised\ + \x20by\x20APIs\x20that\x20do\x20not\x20return\x20enough\x20error\x20info\ + rmation\n\x20may\x20be\x20converted\x20to\x20this\x20error.\n\n\x20HTTP\ + \x20Mapping:\x20500\x20Internal\x20Server\x20Error\n\n\x0c\n\x05\x05\0\ + \x02\x02\x01\x12\x032\x02\t\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x032\x0c\r\ + \n\x92\x02\n\x04\x05\0\x02\x03\x12\x03:\x02\x17\x1a\x84\x02\x20The\x20cl\ + ient\x20specified\x20an\x20invalid\x20argument.\x20\x20Note\x20that\x20t\ + his\x20differs\n\x20from\x20`FAILED_PRECONDITION`.\x20\x20`INVALID_ARGUM\ + ENT`\x20indicates\x20arguments\n\x20that\x20are\x20problematic\x20regard\ + less\x20of\x20the\x20state\x20of\x20the\x20system\n\x20(e.g.,\x20a\x20ma\ + lformed\x20file\x20name).\n\n\x20HTTP\x20Mapping:\x20400\x20Bad\x20Reque\ + st\n\n\x0c\n\x05\x05\0\x02\x03\x01\x12\x03:\x02\x12\n\x0c\n\x05\x05\0\ + \x02\x03\x02\x12\x03:\x15\x16\n\xe4\x02\n\x04\x05\0\x02\x04\x12\x03C\x02\ + \x18\x1a\xd6\x02\x20The\x20deadline\x20expired\x20before\x20the\x20opera\ + tion\x20could\x20complete.\x20For\x20operations\n\x20that\x20change\x20t\ + he\x20state\x20of\x20the\x20system,\x20this\x20error\x20may\x20be\x20ret\ + urned\n\x20even\x20if\x20the\x20operation\x20has\x20completed\x20success\ + fully.\x20\x20For\x20example,\x20a\n\x20successful\x20response\x20from\ + \x20a\x20server\x20could\x20have\x20been\x20delayed\x20long\n\x20enough\ + \x20for\x20the\x20deadline\x20to\x20expire.\n\n\x20HTTP\x20Mapping:\x205\ + 04\x20Gateway\x20Timeout\n\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03C\x02\ + \x13\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03C\x16\x17\n\x9a\x03\n\x04\x05\ + \0\x02\x05\x12\x03N\x02\x10\x1a\x8c\x03\x20Some\x20requested\x20entity\ + \x20(e.g.,\x20file\x20or\x20directory)\x20was\x20not\x20found.\n\n\x20No\ + te\x20to\x20server\x20developers:\x20if\x20a\x20request\x20is\x20denied\ + \x20for\x20an\x20entire\x20class\n\x20of\x20users,\x20such\x20as\x20grad\ + ual\x20feature\x20rollout\x20or\x20undocumented\x20whitelist,\n\x20`NOT_\ + FOUND`\x20may\x20be\x20used.\x20If\x20a\x20request\x20is\x20denied\x20fo\ + r\x20some\x20users\x20within\n\x20a\x20class\x20of\x20users,\x20such\x20\ + as\x20user-based\x20access\x20control,\x20`PERMISSION_DENIED`\n\x20must\ + \x20be\x20used.\n\n\x20HTTP\x20Mapping:\x20404\x20Not\x20Found\n\n\x0c\n\ + \x05\x05\0\x02\x05\x01\x12\x03N\x02\x0b\n\x0c\n\x05\x05\0\x02\x05\x02\ + \x12\x03N\x0e\x0f\n\x83\x01\n\x04\x05\0\x02\x06\x12\x03T\x02\x15\x1av\ + \x20The\x20entity\x20that\x20a\x20client\x20attempted\x20to\x20create\ + \x20(e.g.,\x20file\x20or\x20directory)\n\x20already\x20exists.\n\n\x20HT\ + TP\x20Mapping:\x20409\x20Conflict\n\n\x0c\n\x05\x05\0\x02\x06\x01\x12\ + \x03T\x02\x10\n\x0c\n\x05\x05\0\x02\x06\x02\x12\x03T\x13\x14\n\xf9\x03\n\ + \x04\x05\0\x02\x07\x12\x03`\x02\x18\x1a\xeb\x03\x20The\x20caller\x20does\ + \x20not\x20have\x20permission\x20to\x20execute\x20the\x20specified\n\x20\ + operation.\x20`PERMISSION_DENIED`\x20must\x20not\x20be\x20used\x20for\ + \x20rejections\n\x20caused\x20by\x20exhausting\x20some\x20resource\x20(u\ + se\x20`RESOURCE_EXHAUSTED`\n\x20instead\x20for\x20those\x20errors).\x20`\ + PERMISSION_DENIED`\x20must\x20not\x20be\n\x20used\x20if\x20the\x20caller\ + \x20can\x20not\x20be\x20identified\x20(use\x20`UNAUTHENTICATED`\n\x20ins\ + tead\x20for\x20those\x20errors).\x20This\x20error\x20code\x20does\x20not\ + \x20imply\x20the\n\x20request\x20is\x20valid\x20or\x20the\x20requested\ + \x20entity\x20exists\x20or\x20satisfies\n\x20other\x20pre-conditions.\n\ + \n\x20HTTP\x20Mapping:\x20403\x20Forbidden\n\n\x0c\n\x05\x05\0\x02\x07\ + \x01\x12\x03`\x02\x13\n\x0c\n\x05\x05\0\x02\x07\x02\x12\x03`\x16\x17\n~\ + \n\x04\x05\0\x02\x08\x12\x03f\x02\x17\x1aq\x20The\x20request\x20does\x20\ + not\x20have\x20valid\x20authentication\x20credentials\x20for\x20the\n\ + \x20operation.\n\n\x20HTTP\x20Mapping:\x20401\x20Unauthorized\n\n\x0c\n\ + \x05\x05\0\x02\x08\x01\x12\x03f\x02\x11\n\x0c\n\x05\x05\0\x02\x08\x02\ + \x12\x03f\x14\x16\n\xa5\x01\n\x04\x05\0\x02\t\x12\x03l\x02\x19\x1a\x97\ + \x01\x20Some\x20resource\x20has\x20been\x20exhausted,\x20perhaps\x20a\ + \x20per-user\x20quota,\x20or\n\x20perhaps\x20the\x20entire\x20file\x20sy\ + stem\x20is\x20out\x20of\x20space.\n\n\x20HTTP\x20Mapping:\x20429\x20Too\ + \x20Many\x20Requests\n\n\x0c\n\x05\x05\0\x02\t\x01\x12\x03l\x02\x14\n\ + \x0c\n\x05\x05\0\x02\t\x02\x12\x03l\x17\x18\n\xd9\x07\n\x04\x05\0\x02\n\ + \x12\x04\x80\x01\x02\x1a\x1a\xca\x07\x20The\x20operation\x20was\x20rejec\ + ted\x20because\x20the\x20system\x20is\x20not\x20in\x20a\x20state\n\x20re\ + quired\x20for\x20the\x20operation's\x20execution.\x20\x20For\x20example,\ + \x20the\x20directory\n\x20to\x20be\x20deleted\x20is\x20non-empty,\x20an\ + \x20rmdir\x20operation\x20is\x20applied\x20to\n\x20a\x20non-directory,\ + \x20etc.\n\n\x20Service\x20implementors\x20can\x20use\x20the\x20followin\ + g\x20guidelines\x20to\x20decide\n\x20between\x20`FAILED_PRECONDITION`,\ + \x20`ABORTED`,\x20and\x20`UNAVAILABLE`:\n\x20\x20(a)\x20Use\x20`UNAVAILA\ + BLE`\x20if\x20the\x20client\x20can\x20retry\x20just\x20the\x20failing\ + \x20call.\n\x20\x20(b)\x20Use\x20`ABORTED`\x20if\x20the\x20client\x20sho\ + uld\x20retry\x20at\x20a\x20higher\x20level\n\x20\x20\x20\x20\x20\x20(e.g\ + .,\x20when\x20a\x20client-specified\x20test-and-set\x20fails,\x20indicat\ + ing\x20the\n\x20\x20\x20\x20\x20\x20client\x20should\x20restart\x20a\x20\ + read-modify-write\x20sequence).\n\x20\x20(c)\x20Use\x20`FAILED_PRECONDIT\ + ION`\x20if\x20the\x20client\x20should\x20not\x20retry\x20until\n\x20\x20\ + \x20\x20\x20\x20the\x20system\x20state\x20has\x20been\x20explicitly\x20f\ + ixed.\x20\x20E.g.,\x20if\x20an\x20\"rmdir\"\n\x20\x20\x20\x20\x20\x20fai\ + ls\x20because\x20the\x20directory\x20is\x20non-empty,\x20`FAILED_PRECOND\ + ITION`\n\x20\x20\x20\x20\x20\x20should\x20be\x20returned\x20since\x20the\ + \x20client\x20should\x20not\x20retry\x20unless\n\x20\x20\x20\x20\x20\x20\ + the\x20files\x20are\x20deleted\x20from\x20the\x20directory.\n\n\x20HTTP\ + \x20Mapping:\x20400\x20Bad\x20Request\n\n\r\n\x05\x05\0\x02\n\x01\x12\ + \x04\x80\x01\x02\x15\n\r\n\x05\x05\0\x02\n\x02\x12\x04\x80\x01\x18\x19\n\ + \x8c\x02\n\x04\x05\0\x02\x0b\x12\x04\x89\x01\x02\x0f\x1a\xfd\x01\x20The\ + \x20operation\x20was\x20aborted,\x20typically\x20due\x20to\x20a\x20concu\ + rrency\x20issue\x20such\x20as\n\x20a\x20sequencer\x20check\x20failure\ + \x20or\x20transaction\x20abort.\n\n\x20See\x20the\x20guidelines\x20above\ + \x20for\x20deciding\x20between\x20`FAILED_PRECONDITION`,\n\x20`ABORTED`,\ + \x20and\x20`UNAVAILABLE`.\n\n\x20HTTP\x20Mapping:\x20409\x20Conflict\n\n\ + \r\n\x05\x05\0\x02\x0b\x01\x12\x04\x89\x01\x02\t\n\r\n\x05\x05\0\x02\x0b\ + \x02\x12\x04\x89\x01\x0c\x0e\n\x85\x06\n\x04\x05\0\x02\x0c\x12\x04\x9c\ + \x01\x02\x14\x1a\xf6\x05\x20The\x20operation\x20was\x20attempted\x20past\ + \x20the\x20valid\x20range.\x20\x20E.g.,\x20seeking\x20or\n\x20reading\ + \x20past\x20end-of-file.\n\n\x20Unlike\x20`INVALID_ARGUMENT`,\x20this\ + \x20error\x20indicates\x20a\x20problem\x20that\x20may\n\x20be\x20fixed\ + \x20if\x20the\x20system\x20state\x20changes.\x20For\x20example,\x20a\x20\ + 32-bit\x20file\n\x20system\x20will\x20generate\x20`INVALID_ARGUMENT`\x20\ + if\x20asked\x20to\x20read\x20at\x20an\n\x20offset\x20that\x20is\x20not\ + \x20in\x20the\x20range\x20[0,2^32-1],\x20but\x20it\x20will\x20generate\n\ + \x20`OUT_OF_RANGE`\x20if\x20asked\x20to\x20read\x20from\x20an\x20offset\ + \x20past\x20the\x20current\n\x20file\x20size.\n\n\x20There\x20is\x20a\ + \x20fair\x20bit\x20of\x20overlap\x20between\x20`FAILED_PRECONDITION`\x20\ + and\n\x20`OUT_OF_RANGE`.\x20\x20We\x20recommend\x20using\x20`OUT_OF_RANG\ + E`\x20(the\x20more\x20specific\n\x20error)\x20when\x20it\x20applies\x20s\ + o\x20that\x20callers\x20who\x20are\x20iterating\x20through\n\x20a\x20spa\ + ce\x20can\x20easily\x20look\x20for\x20an\x20`OUT_OF_RANGE`\x20error\x20t\ + o\x20detect\x20when\n\x20they\x20are\x20done.\n\n\x20HTTP\x20Mapping:\ + \x20400\x20Bad\x20Request\n\n\r\n\x05\x05\0\x02\x0c\x01\x12\x04\x9c\x01\ + \x02\x0e\n\r\n\x05\x05\0\x02\x0c\x02\x12\x04\x9c\x01\x11\x13\n\x82\x01\n\ + \x04\x05\0\x02\r\x12\x04\xa2\x01\x02\x15\x1at\x20The\x20operation\x20is\ + \x20not\x20implemented\x20or\x20is\x20not\x20supported/enabled\x20in\x20\ + this\n\x20service.\n\n\x20HTTP\x20Mapping:\x20501\x20Not\x20Implemented\ + \n\n\r\n\x05\x05\0\x02\r\x01\x12\x04\xa2\x01\x02\x0f\n\r\n\x05\x05\0\x02\ + \r\x02\x12\x04\xa2\x01\x12\x14\n\xd3\x01\n\x04\x05\0\x02\x0e\x12\x04\xa9\ + \x01\x02\x10\x1a\xc4\x01\x20Internal\x20errors.\x20\x20This\x20means\x20\ + that\x20some\x20invariants\x20expected\x20by\x20the\n\x20underlying\x20s\ + ystem\x20have\x20been\x20broken.\x20\x20This\x20error\x20code\x20is\x20r\ + eserved\n\x20for\x20serious\x20errors.\n\n\x20HTTP\x20Mapping:\x20500\ + \x20Internal\x20Server\x20Error\n\n\r\n\x05\x05\0\x02\x0e\x01\x12\x04\ + \xa9\x01\x02\n\n\r\n\x05\x05\0\x02\x0e\x02\x12\x04\xa9\x01\r\x0f\n\xa5\ + \x02\n\x04\x05\0\x02\x0f\x12\x04\xb3\x01\x02\x13\x1a\x96\x02\x20The\x20s\ + ervice\x20is\x20currently\x20unavailable.\x20\x20This\x20is\x20most\x20l\ + ikely\x20a\n\x20transient\x20condition,\x20which\x20can\x20be\x20correct\ + ed\x20by\x20retrying\x20with\n\x20a\x20backoff.\n\n\x20See\x20the\x20gui\ + delines\x20above\x20for\x20deciding\x20between\x20`FAILED_PRECONDITION`,\ + \n\x20`ABORTED`,\x20and\x20`UNAVAILABLE`.\n\n\x20HTTP\x20Mapping:\x20503\ + \x20Service\x20Unavailable\n\n\r\n\x05\x05\0\x02\x0f\x01\x12\x04\xb3\x01\ + \x02\r\n\r\n\x05\x05\0\x02\x0f\x02\x12\x04\xb3\x01\x10\x12\n`\n\x04\x05\ + \0\x02\x10\x12\x04\xb8\x01\x02\x11\x1aR\x20Unrecoverable\x20data\x20loss\ + \x20or\x20corruption.\n\n\x20HTTP\x20Mapping:\x20500\x20Internal\x20Serv\ + er\x20Error\n\n\r\n\x05\x05\0\x02\x10\x01\x12\x04\xb8\x01\x02\x0b\n\r\n\ + \x05\x05\0\x02\x10\x02\x12\x04\xb8\x01\x0e\x10b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/error_details.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/error_details.rs new file mode 100644 index 00000000..ac34d680 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/error_details.rs @@ -0,0 +1,3013 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/rpc/error_details.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct RetryInfo { + // message fields + pub retry_delay: ::protobuf::SingularPtrField<::protobuf::well_known_types::Duration>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RetryInfo { + fn default() -> &'a RetryInfo { + ::default_instance() + } +} + +impl RetryInfo { + pub fn new() -> RetryInfo { + ::std::default::Default::default() + } + + // .google.protobuf.Duration retry_delay = 1; + + + pub fn get_retry_delay(&self) -> &::protobuf::well_known_types::Duration { + self.retry_delay.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Duration::default_instance()) + } + pub fn clear_retry_delay(&mut self) { + self.retry_delay.clear(); + } + + pub fn has_retry_delay(&self) -> bool { + self.retry_delay.is_some() + } + + // Param is passed by value, moved + pub fn set_retry_delay(&mut self, v: ::protobuf::well_known_types::Duration) { + self.retry_delay = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_retry_delay(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if self.retry_delay.is_none() { + self.retry_delay.set_default(); + } + self.retry_delay.as_mut().unwrap() + } + + // Take field + pub fn take_retry_delay(&mut self) -> ::protobuf::well_known_types::Duration { + self.retry_delay.take().unwrap_or_else(|| ::protobuf::well_known_types::Duration::new()) + } +} + +impl ::protobuf::Message for RetryInfo { + fn is_initialized(&self) -> bool { + for v in &self.retry_delay { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.retry_delay)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.retry_delay.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.retry_delay.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RetryInfo { + RetryInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Duration>>( + "retry_delay", + |m: &RetryInfo| { &m.retry_delay }, + |m: &mut RetryInfo| { &mut m.retry_delay }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RetryInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RetryInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RetryInfo, + }; + unsafe { + instance.get(RetryInfo::new) + } + } +} + +impl ::protobuf::Clear for RetryInfo { + fn clear(&mut self) { + self.retry_delay.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RetryInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RetryInfo { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DebugInfo { + // message fields + pub stack_entries: ::protobuf::RepeatedField<::std::string::String>, + pub detail: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DebugInfo { + fn default() -> &'a DebugInfo { + ::default_instance() + } +} + +impl DebugInfo { + pub fn new() -> DebugInfo { + ::std::default::Default::default() + } + + // repeated string stack_entries = 1; + + + pub fn get_stack_entries(&self) -> &[::std::string::String] { + &self.stack_entries + } + pub fn clear_stack_entries(&mut self) { + self.stack_entries.clear(); + } + + // Param is passed by value, moved + pub fn set_stack_entries(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.stack_entries = v; + } + + // Mutable pointer to the field. + pub fn mut_stack_entries(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.stack_entries + } + + // Take field + pub fn take_stack_entries(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.stack_entries, ::protobuf::RepeatedField::new()) + } + + // string detail = 2; + + + pub fn get_detail(&self) -> &str { + &self.detail + } + pub fn clear_detail(&mut self) { + self.detail.clear(); + } + + // Param is passed by value, moved + pub fn set_detail(&mut self, v: ::std::string::String) { + self.detail = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_detail(&mut self) -> &mut ::std::string::String { + &mut self.detail + } + + // Take field + pub fn take_detail(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.detail, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DebugInfo { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.stack_entries)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.detail)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.stack_entries { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if !self.detail.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.detail); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.stack_entries { + os.write_string(1, &v)?; + }; + if !self.detail.is_empty() { + os.write_string(2, &self.detail)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DebugInfo { + DebugInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "stack_entries", + |m: &DebugInfo| { &m.stack_entries }, + |m: &mut DebugInfo| { &mut m.stack_entries }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "detail", + |m: &DebugInfo| { &m.detail }, + |m: &mut DebugInfo| { &mut m.detail }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DebugInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DebugInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DebugInfo, + }; + unsafe { + instance.get(DebugInfo::new) + } + } +} + +impl ::protobuf::Clear for DebugInfo { + fn clear(&mut self) { + self.stack_entries.clear(); + self.detail.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DebugInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DebugInfo { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct QuotaFailure { + // message fields + pub violations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a QuotaFailure { + fn default() -> &'a QuotaFailure { + ::default_instance() + } +} + +impl QuotaFailure { + pub fn new() -> QuotaFailure { + ::std::default::Default::default() + } + + // repeated .google.rpc.QuotaFailure.Violation violations = 1; + + + pub fn get_violations(&self) -> &[QuotaFailure_Violation] { + &self.violations + } + pub fn clear_violations(&mut self) { + self.violations.clear(); + } + + // Param is passed by value, moved + pub fn set_violations(&mut self, v: ::protobuf::RepeatedField) { + self.violations = v; + } + + // Mutable pointer to the field. + pub fn mut_violations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.violations + } + + // Take field + pub fn take_violations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.violations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for QuotaFailure { + fn is_initialized(&self) -> bool { + for v in &self.violations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.violations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.violations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.violations { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> QuotaFailure { + QuotaFailure::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "violations", + |m: &QuotaFailure| { &m.violations }, + |m: &mut QuotaFailure| { &mut m.violations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "QuotaFailure", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static QuotaFailure { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const QuotaFailure, + }; + unsafe { + instance.get(QuotaFailure::new) + } + } +} + +impl ::protobuf::Clear for QuotaFailure { + fn clear(&mut self) { + self.violations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for QuotaFailure { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for QuotaFailure { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct QuotaFailure_Violation { + // message fields + pub subject: ::std::string::String, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a QuotaFailure_Violation { + fn default() -> &'a QuotaFailure_Violation { + ::default_instance() + } +} + +impl QuotaFailure_Violation { + pub fn new() -> QuotaFailure_Violation { + ::std::default::Default::default() + } + + // string subject = 1; + + + pub fn get_subject(&self) -> &str { + &self.subject + } + pub fn clear_subject(&mut self) { + self.subject.clear(); + } + + // Param is passed by value, moved + pub fn set_subject(&mut self, v: ::std::string::String) { + self.subject = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subject(&mut self) -> &mut ::std::string::String { + &mut self.subject + } + + // Take field + pub fn take_subject(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subject, ::std::string::String::new()) + } + + // string description = 2; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for QuotaFailure_Violation { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subject)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.subject.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.subject); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.subject.is_empty() { + os.write_string(1, &self.subject)?; + } + if !self.description.is_empty() { + os.write_string(2, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> QuotaFailure_Violation { + QuotaFailure_Violation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subject", + |m: &QuotaFailure_Violation| { &m.subject }, + |m: &mut QuotaFailure_Violation| { &mut m.subject }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &QuotaFailure_Violation| { &m.description }, + |m: &mut QuotaFailure_Violation| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "QuotaFailure_Violation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static QuotaFailure_Violation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const QuotaFailure_Violation, + }; + unsafe { + instance.get(QuotaFailure_Violation::new) + } + } +} + +impl ::protobuf::Clear for QuotaFailure_Violation { + fn clear(&mut self) { + self.subject.clear(); + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for QuotaFailure_Violation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for QuotaFailure_Violation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PreconditionFailure { + // message fields + pub violations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PreconditionFailure { + fn default() -> &'a PreconditionFailure { + ::default_instance() + } +} + +impl PreconditionFailure { + pub fn new() -> PreconditionFailure { + ::std::default::Default::default() + } + + // repeated .google.rpc.PreconditionFailure.Violation violations = 1; + + + pub fn get_violations(&self) -> &[PreconditionFailure_Violation] { + &self.violations + } + pub fn clear_violations(&mut self) { + self.violations.clear(); + } + + // Param is passed by value, moved + pub fn set_violations(&mut self, v: ::protobuf::RepeatedField) { + self.violations = v; + } + + // Mutable pointer to the field. + pub fn mut_violations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.violations + } + + // Take field + pub fn take_violations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.violations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for PreconditionFailure { + fn is_initialized(&self) -> bool { + for v in &self.violations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.violations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.violations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.violations { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PreconditionFailure { + PreconditionFailure::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "violations", + |m: &PreconditionFailure| { &m.violations }, + |m: &mut PreconditionFailure| { &mut m.violations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PreconditionFailure", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PreconditionFailure { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PreconditionFailure, + }; + unsafe { + instance.get(PreconditionFailure::new) + } + } +} + +impl ::protobuf::Clear for PreconditionFailure { + fn clear(&mut self) { + self.violations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PreconditionFailure { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PreconditionFailure { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PreconditionFailure_Violation { + // message fields + pub field_type: ::std::string::String, + pub subject: ::std::string::String, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PreconditionFailure_Violation { + fn default() -> &'a PreconditionFailure_Violation { + ::default_instance() + } +} + +impl PreconditionFailure_Violation { + pub fn new() -> PreconditionFailure_Violation { + ::std::default::Default::default() + } + + // string type = 1; + + + pub fn get_field_type(&self) -> &str { + &self.field_type + } + pub fn clear_field_type(&mut self) { + self.field_type.clear(); + } + + // Param is passed by value, moved + pub fn set_field_type(&mut self, v: ::std::string::String) { + self.field_type = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_field_type(&mut self) -> &mut ::std::string::String { + &mut self.field_type + } + + // Take field + pub fn take_field_type(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.field_type, ::std::string::String::new()) + } + + // string subject = 2; + + + pub fn get_subject(&self) -> &str { + &self.subject + } + pub fn clear_subject(&mut self) { + self.subject.clear(); + } + + // Param is passed by value, moved + pub fn set_subject(&mut self, v: ::std::string::String) { + self.subject = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_subject(&mut self) -> &mut ::std::string::String { + &mut self.subject + } + + // Take field + pub fn take_subject(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.subject, ::std::string::String::new()) + } + + // string description = 3; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for PreconditionFailure_Violation { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.subject)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.field_type.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.field_type); + } + if !self.subject.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.subject); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.field_type.is_empty() { + os.write_string(1, &self.field_type)?; + } + if !self.subject.is_empty() { + os.write_string(2, &self.subject)?; + } + if !self.description.is_empty() { + os.write_string(3, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PreconditionFailure_Violation { + PreconditionFailure_Violation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "type", + |m: &PreconditionFailure_Violation| { &m.field_type }, + |m: &mut PreconditionFailure_Violation| { &mut m.field_type }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "subject", + |m: &PreconditionFailure_Violation| { &m.subject }, + |m: &mut PreconditionFailure_Violation| { &mut m.subject }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &PreconditionFailure_Violation| { &m.description }, + |m: &mut PreconditionFailure_Violation| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PreconditionFailure_Violation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PreconditionFailure_Violation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PreconditionFailure_Violation, + }; + unsafe { + instance.get(PreconditionFailure_Violation::new) + } + } +} + +impl ::protobuf::Clear for PreconditionFailure_Violation { + fn clear(&mut self) { + self.field_type.clear(); + self.subject.clear(); + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PreconditionFailure_Violation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PreconditionFailure_Violation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct BadRequest { + // message fields + pub field_violations: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BadRequest { + fn default() -> &'a BadRequest { + ::default_instance() + } +} + +impl BadRequest { + pub fn new() -> BadRequest { + ::std::default::Default::default() + } + + // repeated .google.rpc.BadRequest.FieldViolation field_violations = 1; + + + pub fn get_field_violations(&self) -> &[BadRequest_FieldViolation] { + &self.field_violations + } + pub fn clear_field_violations(&mut self) { + self.field_violations.clear(); + } + + // Param is passed by value, moved + pub fn set_field_violations(&mut self, v: ::protobuf::RepeatedField) { + self.field_violations = v; + } + + // Mutable pointer to the field. + pub fn mut_field_violations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.field_violations + } + + // Take field + pub fn take_field_violations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.field_violations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for BadRequest { + fn is_initialized(&self) -> bool { + for v in &self.field_violations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.field_violations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.field_violations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.field_violations { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BadRequest { + BadRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "field_violations", + |m: &BadRequest| { &m.field_violations }, + |m: &mut BadRequest| { &mut m.field_violations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BadRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BadRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BadRequest, + }; + unsafe { + instance.get(BadRequest::new) + } + } +} + +impl ::protobuf::Clear for BadRequest { + fn clear(&mut self) { + self.field_violations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BadRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BadRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct BadRequest_FieldViolation { + // message fields + pub field: ::std::string::String, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BadRequest_FieldViolation { + fn default() -> &'a BadRequest_FieldViolation { + ::default_instance() + } +} + +impl BadRequest_FieldViolation { + pub fn new() -> BadRequest_FieldViolation { + ::std::default::Default::default() + } + + // string field = 1; + + + pub fn get_field(&self) -> &str { + &self.field + } + pub fn clear_field(&mut self) { + self.field.clear(); + } + + // Param is passed by value, moved + pub fn set_field(&mut self, v: ::std::string::String) { + self.field = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_field(&mut self) -> &mut ::std::string::String { + &mut self.field + } + + // Take field + pub fn take_field(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.field, ::std::string::String::new()) + } + + // string description = 2; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for BadRequest_FieldViolation { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.field.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.field); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.field.is_empty() { + os.write_string(1, &self.field)?; + } + if !self.description.is_empty() { + os.write_string(2, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BadRequest_FieldViolation { + BadRequest_FieldViolation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "field", + |m: &BadRequest_FieldViolation| { &m.field }, + |m: &mut BadRequest_FieldViolation| { &mut m.field }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &BadRequest_FieldViolation| { &m.description }, + |m: &mut BadRequest_FieldViolation| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BadRequest_FieldViolation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BadRequest_FieldViolation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BadRequest_FieldViolation, + }; + unsafe { + instance.get(BadRequest_FieldViolation::new) + } + } +} + +impl ::protobuf::Clear for BadRequest_FieldViolation { + fn clear(&mut self) { + self.field.clear(); + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BadRequest_FieldViolation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BadRequest_FieldViolation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RequestInfo { + // message fields + pub request_id: ::std::string::String, + pub serving_data: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RequestInfo { + fn default() -> &'a RequestInfo { + ::default_instance() + } +} + +impl RequestInfo { + pub fn new() -> RequestInfo { + ::std::default::Default::default() + } + + // string request_id = 1; + + + pub fn get_request_id(&self) -> &str { + &self.request_id + } + pub fn clear_request_id(&mut self) { + self.request_id.clear(); + } + + // Param is passed by value, moved + pub fn set_request_id(&mut self, v: ::std::string::String) { + self.request_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_id(&mut self) -> &mut ::std::string::String { + &mut self.request_id + } + + // Take field + pub fn take_request_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.request_id, ::std::string::String::new()) + } + + // string serving_data = 2; + + + pub fn get_serving_data(&self) -> &str { + &self.serving_data + } + pub fn clear_serving_data(&mut self) { + self.serving_data.clear(); + } + + // Param is passed by value, moved + pub fn set_serving_data(&mut self, v: ::std::string::String) { + self.serving_data = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_serving_data(&mut self) -> &mut ::std::string::String { + &mut self.serving_data + } + + // Take field + pub fn take_serving_data(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.serving_data, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for RequestInfo { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.request_id)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.serving_data)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.request_id.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.request_id); + } + if !self.serving_data.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.serving_data); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.request_id.is_empty() { + os.write_string(1, &self.request_id)?; + } + if !self.serving_data.is_empty() { + os.write_string(2, &self.serving_data)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RequestInfo { + RequestInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "request_id", + |m: &RequestInfo| { &m.request_id }, + |m: &mut RequestInfo| { &mut m.request_id }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "serving_data", + |m: &RequestInfo| { &m.serving_data }, + |m: &mut RequestInfo| { &mut m.serving_data }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RequestInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RequestInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RequestInfo, + }; + unsafe { + instance.get(RequestInfo::new) + } + } +} + +impl ::protobuf::Clear for RequestInfo { + fn clear(&mut self) { + self.request_id.clear(); + self.serving_data.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RequestInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RequestInfo { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ResourceInfo { + // message fields + pub resource_type: ::std::string::String, + pub resource_name: ::std::string::String, + pub owner: ::std::string::String, + pub description: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ResourceInfo { + fn default() -> &'a ResourceInfo { + ::default_instance() + } +} + +impl ResourceInfo { + pub fn new() -> ResourceInfo { + ::std::default::Default::default() + } + + // string resource_type = 1; + + + pub fn get_resource_type(&self) -> &str { + &self.resource_type + } + pub fn clear_resource_type(&mut self) { + self.resource_type.clear(); + } + + // Param is passed by value, moved + pub fn set_resource_type(&mut self, v: ::std::string::String) { + self.resource_type = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resource_type(&mut self) -> &mut ::std::string::String { + &mut self.resource_type + } + + // Take field + pub fn take_resource_type(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.resource_type, ::std::string::String::new()) + } + + // string resource_name = 2; + + + pub fn get_resource_name(&self) -> &str { + &self.resource_name + } + pub fn clear_resource_name(&mut self) { + self.resource_name.clear(); + } + + // Param is passed by value, moved + pub fn set_resource_name(&mut self, v: ::std::string::String) { + self.resource_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resource_name(&mut self) -> &mut ::std::string::String { + &mut self.resource_name + } + + // Take field + pub fn take_resource_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.resource_name, ::std::string::String::new()) + } + + // string owner = 3; + + + pub fn get_owner(&self) -> &str { + &self.owner + } + pub fn clear_owner(&mut self) { + self.owner.clear(); + } + + // Param is passed by value, moved + pub fn set_owner(&mut self, v: ::std::string::String) { + self.owner = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_owner(&mut self) -> &mut ::std::string::String { + &mut self.owner + } + + // Take field + pub fn take_owner(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.owner, ::std::string::String::new()) + } + + // string description = 4; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ResourceInfo { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resource_type)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.resource_name)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.owner)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.resource_type.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.resource_type); + } + if !self.resource_name.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.resource_name); + } + if !self.owner.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.owner); + } + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.description); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.resource_type.is_empty() { + os.write_string(1, &self.resource_type)?; + } + if !self.resource_name.is_empty() { + os.write_string(2, &self.resource_name)?; + } + if !self.owner.is_empty() { + os.write_string(3, &self.owner)?; + } + if !self.description.is_empty() { + os.write_string(4, &self.description)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ResourceInfo { + ResourceInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "resource_type", + |m: &ResourceInfo| { &m.resource_type }, + |m: &mut ResourceInfo| { &mut m.resource_type }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "resource_name", + |m: &ResourceInfo| { &m.resource_name }, + |m: &mut ResourceInfo| { &mut m.resource_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "owner", + |m: &ResourceInfo| { &m.owner }, + |m: &mut ResourceInfo| { &mut m.owner }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &ResourceInfo| { &m.description }, + |m: &mut ResourceInfo| { &mut m.description }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ResourceInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ResourceInfo { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ResourceInfo, + }; + unsafe { + instance.get(ResourceInfo::new) + } + } +} + +impl ::protobuf::Clear for ResourceInfo { + fn clear(&mut self) { + self.resource_type.clear(); + self.resource_name.clear(); + self.owner.clear(); + self.description.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ResourceInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ResourceInfo { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Help { + // message fields + pub links: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Help { + fn default() -> &'a Help { + ::default_instance() + } +} + +impl Help { + pub fn new() -> Help { + ::std::default::Default::default() + } + + // repeated .google.rpc.Help.Link links = 1; + + + pub fn get_links(&self) -> &[Help_Link] { + &self.links + } + pub fn clear_links(&mut self) { + self.links.clear(); + } + + // Param is passed by value, moved + pub fn set_links(&mut self, v: ::protobuf::RepeatedField) { + self.links = v; + } + + // Mutable pointer to the field. + pub fn mut_links(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.links + } + + // Take field + pub fn take_links(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.links, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Help { + fn is_initialized(&self) -> bool { + for v in &self.links { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.links)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.links { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.links { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Help { + Help::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "links", + |m: &Help| { &m.links }, + |m: &mut Help| { &mut m.links }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Help", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Help { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Help, + }; + unsafe { + instance.get(Help::new) + } + } +} + +impl ::protobuf::Clear for Help { + fn clear(&mut self) { + self.links.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Help { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Help { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Help_Link { + // message fields + pub description: ::std::string::String, + pub url: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Help_Link { + fn default() -> &'a Help_Link { + ::default_instance() + } +} + +impl Help_Link { + pub fn new() -> Help_Link { + ::std::default::Default::default() + } + + // string description = 1; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } + + // string url = 2; + + + pub fn get_url(&self) -> &str { + &self.url + } + pub fn clear_url(&mut self) { + self.url.clear(); + } + + // Param is passed by value, moved + pub fn set_url(&mut self, v: ::std::string::String) { + self.url = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_url(&mut self) -> &mut ::std::string::String { + &mut self.url + } + + // Take field + pub fn take_url(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.url, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Help_Link { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.url)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.description); + } + if !self.url.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.url); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.description.is_empty() { + os.write_string(1, &self.description)?; + } + if !self.url.is_empty() { + os.write_string(2, &self.url)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Help_Link { + Help_Link::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &Help_Link| { &m.description }, + |m: &mut Help_Link| { &mut m.description }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "url", + |m: &Help_Link| { &m.url }, + |m: &mut Help_Link| { &mut m.url }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Help_Link", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Help_Link { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Help_Link, + }; + unsafe { + instance.get(Help_Link::new) + } + } +} + +impl ::protobuf::Clear for Help_Link { + fn clear(&mut self) { + self.description.clear(); + self.url.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Help_Link { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Help_Link { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct LocalizedMessage { + // message fields + pub locale: ::std::string::String, + pub message: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a LocalizedMessage { + fn default() -> &'a LocalizedMessage { + ::default_instance() + } +} + +impl LocalizedMessage { + pub fn new() -> LocalizedMessage { + ::std::default::Default::default() + } + + // string locale = 1; + + + pub fn get_locale(&self) -> &str { + &self.locale + } + pub fn clear_locale(&mut self) { + self.locale.clear(); + } + + // Param is passed by value, moved + pub fn set_locale(&mut self, v: ::std::string::String) { + self.locale = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_locale(&mut self) -> &mut ::std::string::String { + &mut self.locale + } + + // Take field + pub fn take_locale(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.locale, ::std::string::String::new()) + } + + // string message = 2; + + + pub fn get_message(&self) -> &str { + &self.message + } + pub fn clear_message(&mut self) { + self.message.clear(); + } + + // Param is passed by value, moved + pub fn set_message(&mut self, v: ::std::string::String) { + self.message = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message(&mut self) -> &mut ::std::string::String { + &mut self.message + } + + // Take field + pub fn take_message(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.message, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for LocalizedMessage { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.locale)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.locale.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.locale); + } + if !self.message.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.message); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.locale.is_empty() { + os.write_string(1, &self.locale)?; + } + if !self.message.is_empty() { + os.write_string(2, &self.message)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> LocalizedMessage { + LocalizedMessage::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "locale", + |m: &LocalizedMessage| { &m.locale }, + |m: &mut LocalizedMessage| { &mut m.locale }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message", + |m: &LocalizedMessage| { &m.message }, + |m: &mut LocalizedMessage| { &mut m.message }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "LocalizedMessage", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static LocalizedMessage { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const LocalizedMessage, + }; + unsafe { + instance.get(LocalizedMessage::new) + } + } +} + +impl ::protobuf::Clear for LocalizedMessage { + fn clear(&mut self) { + self.locale.clear(); + self.message.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for LocalizedMessage { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for LocalizedMessage { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1egoogle/rpc/error_details.proto\x12\ngoogle.rpc\x1a\x1egoogle/proto\ + buf/duration.proto\"G\n\tRetryInfo\x12:\n\x0bretry_delay\x18\x01\x20\x01\ + (\x0b2\x19.google.protobuf.DurationR\nretryDelay\"H\n\tDebugInfo\x12#\n\ + \rstack_entries\x18\x01\x20\x03(\tR\x0cstackEntries\x12\x16\n\x06detail\ + \x18\x02\x20\x01(\tR\x06detail\"\x9b\x01\n\x0cQuotaFailure\x12B\n\nviola\ + tions\x18\x01\x20\x03(\x0b2\".google.rpc.QuotaFailure.ViolationR\nviolat\ + ions\x1aG\n\tViolation\x12\x18\n\x07subject\x18\x01\x20\x01(\tR\x07subje\ + ct\x12\x20\n\x0bdescription\x18\x02\x20\x01(\tR\x0bdescription\"\xbd\x01\ + \n\x13PreconditionFailure\x12I\n\nviolations\x18\x01\x20\x03(\x0b2).goog\ + le.rpc.PreconditionFailure.ViolationR\nviolations\x1a[\n\tViolation\x12\ + \x12\n\x04type\x18\x01\x20\x01(\tR\x04type\x12\x18\n\x07subject\x18\x02\ + \x20\x01(\tR\x07subject\x12\x20\n\x0bdescription\x18\x03\x20\x01(\tR\x0b\ + description\"\xa8\x01\n\nBadRequest\x12P\n\x10field_violations\x18\x01\ + \x20\x03(\x0b2%.google.rpc.BadRequest.FieldViolationR\x0ffieldViolations\ + \x1aH\n\x0eFieldViolation\x12\x14\n\x05field\x18\x01\x20\x01(\tR\x05fiel\ + d\x12\x20\n\x0bdescription\x18\x02\x20\x01(\tR\x0bdescription\"O\n\x0bRe\ + questInfo\x12\x1d\n\nrequest_id\x18\x01\x20\x01(\tR\trequestId\x12!\n\ + \x0cserving_data\x18\x02\x20\x01(\tR\x0bservingData\"\x90\x01\n\x0cResou\ + rceInfo\x12#\n\rresource_type\x18\x01\x20\x01(\tR\x0cresourceType\x12#\n\ + \rresource_name\x18\x02\x20\x01(\tR\x0cresourceName\x12\x14\n\x05owner\ + \x18\x03\x20\x01(\tR\x05owner\x12\x20\n\x0bdescription\x18\x04\x20\x01(\ + \tR\x0bdescription\"o\n\x04Help\x12+\n\x05links\x18\x01\x20\x03(\x0b2\ + \x15.google.rpc.Help.LinkR\x05links\x1a:\n\x04Link\x12\x20\n\x0bdescript\ + ion\x18\x01\x20\x01(\tR\x0bdescription\x12\x10\n\x03url\x18\x02\x20\x01(\ + \tR\x03url\"D\n\x10LocalizedMessage\x12\x16\n\x06locale\x18\x01\x20\x01(\ + \tR\x06locale\x12\x18\n\x07message\x18\x02\x20\x01(\tR\x07messageBl\n\ + \x0ecom.google.rpcB\x11ErrorDetailsProtoP\x01Z?google.golang.org/genprot\ + o/googleapis/rpc/errdetails;errdetails\xa2\x02\x03RPCJ\xc7@\n\x07\x12\ + \x05\x0e\0\xc7\x01\x01\n\xbd\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\ + \x20Copyright\x202017\x20Google\x20Inc.\n\n\x20Licensed\x20under\x20the\ + \x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20y\ + ou\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20compliance\ + \x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\ + \x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/li\ + censes/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\ + \x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\ + \x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20\ + IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20A\ + NY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20Li\ + cense\x20for\x20the\x20specific\x20language\x20governing\x20permissions\ + \x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\ + \x12\x03\x10\0\x13\n\t\n\x02\x03\0\x12\x03\x12\0(\n\x08\n\x01\x08\x12\ + \x03\x14\0V\n\t\n\x02\x08\x0b\x12\x03\x14\0V\n\x08\n\x01\x08\x12\x03\x15\ + \0\"\n\t\n\x02\x08\n\x12\x03\x15\0\"\n\x08\n\x01\x08\x12\x03\x16\02\n\t\ + \n\x02\x08\x08\x12\x03\x16\02\n\x08\n\x01\x08\x12\x03\x17\0'\n\t\n\x02\ + \x08\x01\x12\x03\x17\0'\n\x08\n\x01\x08\x12\x03\x18\0!\n\t\n\x02\x08$\ + \x12\x03\x18\0!\n\x8b\x05\n\x02\x04\0\x12\x04(\0+\x01\x1a\xfe\x04\x20Des\ + cribes\x20when\x20the\x20clients\x20can\x20retry\x20a\x20failed\x20reque\ + st.\x20Clients\x20could\x20ignore\n\x20the\x20recommendation\x20here\x20\ + or\x20retry\x20when\x20this\x20information\x20is\x20missing\x20from\x20e\ + rror\n\x20responses.\n\n\x20It's\x20always\x20recommended\x20that\x20cli\ + ents\x20should\x20use\x20exponential\x20backoff\x20when\n\x20retrying.\n\ + \n\x20Clients\x20should\x20wait\x20until\x20`retry_delay`\x20amount\x20o\ + f\x20time\x20has\x20passed\x20since\n\x20receiving\x20the\x20error\x20re\ + sponse\x20before\x20retrying.\x20\x20If\x20retrying\x20requests\x20also\ + \n\x20fail,\x20clients\x20should\x20use\x20an\x20exponential\x20backoff\ + \x20scheme\x20to\x20gradually\x20increase\n\x20the\x20delay\x20between\ + \x20retries\x20based\x20on\x20`retry_delay`,\x20until\x20either\x20a\x20\ + maximum\n\x20number\x20of\x20retires\x20have\x20been\x20reached\x20or\ + \x20a\x20maximum\x20retry\x20delay\x20cap\x20has\x20been\n\x20reached.\n\ + \n\n\n\x03\x04\0\x01\x12\x03(\x08\x11\nX\n\x04\x04\0\x02\0\x12\x03*\x02+\ + \x1aK\x20Clients\x20should\x20wait\x20at\x20least\x20this\x20long\x20bet\ + ween\x20retrying\x20the\x20same\x20request.\n\n\r\n\x05\x04\0\x02\0\x04\ + \x12\x04*\x02(\x13\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03*\x02\x1a\n\x0c\n\ + \x05\x04\0\x02\0\x01\x12\x03*\x1b&\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03*)\ + *\n2\n\x02\x04\x01\x12\x04.\04\x01\x1a&\x20Describes\x20additional\x20de\ + bugging\x20info.\n\n\n\n\x03\x04\x01\x01\x12\x03.\x08\x11\nK\n\x04\x04\ + \x01\x02\0\x12\x030\x02$\x1a>\x20The\x20stack\x20trace\x20entries\x20ind\ + icating\x20where\x20the\x20error\x20occurred.\n\n\x0c\n\x05\x04\x01\x02\ + \0\x04\x12\x030\x02\n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x030\x0b\x11\n\ + \x0c\n\x05\x04\x01\x02\0\x01\x12\x030\x12\x1f\n\x0c\n\x05\x04\x01\x02\0\ + \x03\x12\x030\"#\nG\n\x04\x04\x01\x02\x01\x12\x033\x02\x14\x1a:\x20Addit\ + ional\x20debugging\x20information\x20provided\x20by\x20the\x20server.\n\ + \n\r\n\x05\x04\x01\x02\x01\x04\x12\x043\x020$\n\x0c\n\x05\x04\x01\x02\ + \x01\x05\x12\x033\x02\x08\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x033\t\x0f\ + \n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x033\x12\x13\n\xfe\x03\n\x02\x04\ + \x02\x12\x04A\0V\x01\x1a\xf1\x03\x20Describes\x20how\x20a\x20quota\x20ch\ + eck\x20failed.\n\n\x20For\x20example\x20if\x20a\x20daily\x20limit\x20was\ + \x20exceeded\x20for\x20the\x20calling\x20project,\n\x20a\x20service\x20c\ + ould\x20respond\x20with\x20a\x20QuotaFailure\x20detail\x20containing\x20\ + the\x20project\n\x20id\x20and\x20the\x20description\x20of\x20the\x20quot\ + a\x20limit\x20that\x20was\x20exceeded.\x20\x20If\x20the\n\x20calling\x20\ + project\x20hasn't\x20enabled\x20the\x20service\x20in\x20the\x20developer\ + \x20console,\x20then\n\x20a\x20service\x20could\x20respond\x20with\x20th\ + e\x20project\x20id\x20and\x20set\x20`service_disabled`\n\x20to\x20true.\ + \n\n\x20Also\x20see\x20RetryDetail\x20and\x20Help\x20types\x20for\x20oth\ + er\x20details\x20about\x20handling\x20a\n\x20quota\x20failure.\n\n\n\n\ + \x03\x04\x02\x01\x12\x03A\x08\x14\n\x8b\x01\n\x04\x04\x02\x03\0\x12\x04D\ + \x02R\x03\x1a}\x20A\x20message\x20type\x20used\x20to\x20describe\x20a\ + \x20single\x20quota\x20violation.\x20\x20For\x20example,\x20a\n\x20daily\ + \x20quota\x20or\x20a\x20custom\x20quota\x20that\x20was\x20exceeded.\n\n\ + \x0c\n\x05\x04\x02\x03\0\x01\x12\x03D\n\x13\n\x9b\x01\n\x06\x04\x02\x03\ + \0\x02\0\x12\x03H\x04\x17\x1a\x8b\x01\x20The\x20subject\x20on\x20which\ + \x20the\x20quota\x20check\x20failed.\n\x20For\x20example,\x20\"clientip:\ + \"\x20or\x20\"project:\".\n\n\x0f\n\x07\x04\x02\x03\0\x02\0\x04\x12\x04H\ + \x04D\x15\n\x0e\n\x07\x04\x02\x03\0\x02\0\x05\x12\x03H\x04\n\n\x0e\n\x07\ + \x04\x02\x03\0\x02\0\x01\x12\x03H\x0b\x12\n\x0e\n\x07\x04\x02\x03\0\x02\ + \0\x03\x12\x03H\x15\x16\n\xcc\x02\n\x06\x04\x02\x03\0\x02\x01\x12\x03Q\ + \x04\x1b\x1a\xbc\x02\x20A\x20description\x20of\x20how\x20the\x20quota\ + \x20check\x20failed.\x20Clients\x20can\x20use\x20this\n\x20description\ + \x20to\x20find\x20more\x20about\x20the\x20quota\x20configuration\x20in\ + \x20the\x20service's\n\x20public\x20documentation,\x20or\x20find\x20the\ + \x20relevant\x20quota\x20limit\x20to\x20adjust\x20through\n\x20developer\ + \x20console.\n\n\x20For\x20example:\x20\"Service\x20disabled\"\x20or\x20\ + \"Daily\x20Limit\x20for\x20read\x20operations\n\x20exceeded\".\n\n\x0f\n\ + \x07\x04\x02\x03\0\x02\x01\x04\x12\x04Q\x04H\x17\n\x0e\n\x07\x04\x02\x03\ + \0\x02\x01\x05\x12\x03Q\x04\n\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x01\x12\ + \x03Q\x0b\x16\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x03Q\x19\x1a\n.\ + \n\x04\x04\x02\x02\0\x12\x03U\x02$\x1a!\x20Describes\x20all\x20quota\x20\ + violations.\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03U\x02\n\n\x0c\n\x05\ + \x04\x02\x02\0\x06\x12\x03U\x0b\x14\n\x0c\n\x05\x04\x02\x02\0\x01\x12\ + \x03U\x15\x1f\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03U\"#\n\xe8\x01\n\x02\ + \x04\x03\x12\x04]\0s\x01\x1a\xdb\x01\x20Describes\x20what\x20preconditio\ + ns\x20have\x20failed.\n\n\x20For\x20example,\x20if\x20an\x20RPC\x20faile\ + d\x20because\x20it\x20required\x20the\x20Terms\x20of\x20Service\x20to\ + \x20be\n\x20acknowledged,\x20it\x20could\x20list\x20the\x20terms\x20of\ + \x20service\x20violation\x20in\x20the\n\x20PreconditionFailure\x20messag\ + e.\n\n\n\n\x03\x04\x03\x01\x12\x03]\x08\x1b\nN\n\x04\x04\x03\x03\0\x12\ + \x04_\x02o\x03\x1a@\x20A\x20message\x20type\x20used\x20to\x20describe\ + \x20a\x20single\x20precondition\x20failure.\n\n\x0c\n\x05\x04\x03\x03\0\ + \x01\x12\x03_\n\x13\n\xcf\x01\n\x06\x04\x03\x03\0\x02\0\x12\x03c\x04\x14\ + \x1a\xbf\x01\x20The\x20type\x20of\x20PreconditionFailure.\x20We\x20recom\ + mend\x20using\x20a\x20service-specific\n\x20enum\x20type\x20to\x20define\ + \x20the\x20supported\x20precondition\x20violation\x20types.\x20For\n\x20\ + example,\x20\"TOS\"\x20for\x20\"Terms\x20of\x20Service\x20violation\".\n\ + \n\x0f\n\x07\x04\x03\x03\0\x02\0\x04\x12\x04c\x04_\x15\n\x0e\n\x07\x04\ + \x03\x03\0\x02\0\x05\x12\x03c\x04\n\n\x0e\n\x07\x04\x03\x03\0\x02\0\x01\ + \x12\x03c\x0b\x0f\n\x0e\n\x07\x04\x03\x03\0\x02\0\x03\x12\x03c\x12\x13\n\ + \xb9\x01\n\x06\x04\x03\x03\0\x02\x01\x12\x03h\x04\x17\x1a\xa9\x01\x20The\ + \x20subject,\x20relative\x20to\x20the\x20type,\x20that\x20failed.\n\x20F\ + or\x20example,\x20\"google.com/cloud\"\x20relative\x20to\x20the\x20\"TOS\ + \"\x20type\x20would\n\x20indicate\x20which\x20terms\x20of\x20service\x20\ + is\x20being\x20referenced.\n\n\x0f\n\x07\x04\x03\x03\0\x02\x01\x04\x12\ + \x04h\x04c\x14\n\x0e\n\x07\x04\x03\x03\0\x02\x01\x05\x12\x03h\x04\n\n\ + \x0e\n\x07\x04\x03\x03\0\x02\x01\x01\x12\x03h\x0b\x12\n\x0e\n\x07\x04\ + \x03\x03\0\x02\x01\x03\x12\x03h\x15\x16\n\xba\x01\n\x06\x04\x03\x03\0\ + \x02\x02\x12\x03n\x04\x1b\x1a\xaa\x01\x20A\x20description\x20of\x20how\ + \x20the\x20precondition\x20failed.\x20Developers\x20can\x20use\x20this\n\ + \x20description\x20to\x20understand\x20how\x20to\x20fix\x20the\x20failur\ + e.\n\n\x20For\x20example:\x20\"Terms\x20of\x20service\x20not\x20accepted\ + \".\n\n\x0f\n\x07\x04\x03\x03\0\x02\x02\x04\x12\x04n\x04h\x17\n\x0e\n\ + \x07\x04\x03\x03\0\x02\x02\x05\x12\x03n\x04\n\n\x0e\n\x07\x04\x03\x03\0\ + \x02\x02\x01\x12\x03n\x0b\x16\n\x0e\n\x07\x04\x03\x03\0\x02\x02\x03\x12\ + \x03n\x19\x1a\n5\n\x04\x04\x03\x02\0\x12\x03r\x02$\x1a(\x20Describes\x20\ + all\x20precondition\x20violations.\n\n\x0c\n\x05\x04\x03\x02\0\x04\x12\ + \x03r\x02\n\n\x0c\n\x05\x04\x03\x02\0\x06\x12\x03r\x0b\x14\n\x0c\n\x05\ + \x04\x03\x02\0\x01\x12\x03r\x15\x1f\n\x0c\n\x05\x04\x03\x02\0\x03\x12\ + \x03r\"#\nz\n\x02\x04\x04\x12\x05w\0\x85\x01\x01\x1am\x20Describes\x20vi\ + olations\x20in\x20a\x20client\x20request.\x20This\x20error\x20type\x20fo\ + cuses\x20on\x20the\n\x20syntactic\x20aspects\x20of\x20the\x20request.\n\ + \n\n\n\x03\x04\x04\x01\x12\x03w\x08\x12\nL\n\x04\x04\x04\x03\0\x12\x05y\ + \x02\x81\x01\x03\x1a=\x20A\x20message\x20type\x20used\x20to\x20describe\ + \x20a\x20single\x20bad\x20request\x20field.\n\n\x0c\n\x05\x04\x04\x03\0\ + \x01\x12\x03y\n\x18\n\xdd\x01\n\x06\x04\x04\x03\0\x02\0\x12\x03}\x04\x15\ + \x1a\xcd\x01\x20A\x20path\x20leading\x20to\x20a\x20field\x20in\x20the\ + \x20request\x20body.\x20The\x20value\x20will\x20be\x20a\n\x20sequence\ + \x20of\x20dot-separated\x20identifiers\x20that\x20identify\x20a\x20proto\ + col\x20buffer\n\x20field.\x20E.g.,\x20\"field_violations.field\"\x20woul\ + d\x20identify\x20this\x20field.\n\n\x0f\n\x07\x04\x04\x03\0\x02\0\x04\ + \x12\x04}\x04y\x1a\n\x0e\n\x07\x04\x04\x03\0\x02\0\x05\x12\x03}\x04\n\n\ + \x0e\n\x07\x04\x04\x03\0\x02\0\x01\x12\x03}\x0b\x10\n\x0e\n\x07\x04\x04\ + \x03\0\x02\0\x03\x12\x03}\x13\x14\nB\n\x06\x04\x04\x03\0\x02\x01\x12\x04\ + \x80\x01\x04\x1b\x1a2\x20A\x20description\x20of\x20why\x20the\x20request\ + \x20element\x20is\x20bad.\n\n\x10\n\x07\x04\x04\x03\0\x02\x01\x04\x12\ + \x05\x80\x01\x04}\x15\n\x0f\n\x07\x04\x04\x03\0\x02\x01\x05\x12\x04\x80\ + \x01\x04\n\n\x0f\n\x07\x04\x04\x03\0\x02\x01\x01\x12\x04\x80\x01\x0b\x16\ + \n\x0f\n\x07\x04\x04\x03\0\x02\x01\x03\x12\x04\x80\x01\x19\x1a\n=\n\x04\ + \x04\x04\x02\0\x12\x04\x84\x01\x02/\x1a/\x20Describes\x20all\x20violatio\ + ns\x20in\x20a\x20client\x20request.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\ + \x04\x84\x01\x02\n\n\r\n\x05\x04\x04\x02\0\x06\x12\x04\x84\x01\x0b\x19\n\ + \r\n\x05\x04\x04\x02\0\x01\x12\x04\x84\x01\x1a*\n\r\n\x05\x04\x04\x02\0\ + \x03\x12\x04\x84\x01-.\n\x84\x01\n\x02\x04\x05\x12\x06\x89\x01\0\x91\x01\ + \x01\x1av\x20Contains\x20metadata\x20about\x20the\x20request\x20that\x20\ + clients\x20can\x20attach\x20when\x20filing\x20a\x20bug\n\x20or\x20provid\ + ing\x20other\x20forms\x20of\x20feedback.\n\n\x0b\n\x03\x04\x05\x01\x12\ + \x04\x89\x01\x08\x13\n\xa8\x01\n\x04\x04\x05\x02\0\x12\x04\x8c\x01\x02\ + \x18\x1a\x99\x01\x20An\x20opaque\x20string\x20that\x20should\x20only\x20\ + be\x20interpreted\x20by\x20the\x20service\x20generating\n\x20it.\x20For\ + \x20example,\x20it\x20can\x20be\x20used\x20to\x20identify\x20requests\ + \x20in\x20the\x20service's\x20logs.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\ + \x06\x8c\x01\x02\x89\x01\x15\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x8c\x01\ + \x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x8c\x01\t\x13\n\r\n\x05\x04\ + \x05\x02\0\x03\x12\x04\x8c\x01\x16\x17\n\xa2\x01\n\x04\x04\x05\x02\x01\ + \x12\x04\x90\x01\x02\x1a\x1a\x93\x01\x20Any\x20data\x20that\x20was\x20us\ + ed\x20to\x20serve\x20this\x20request.\x20For\x20example,\x20an\x20encryp\ + ted\n\x20stack\x20trace\x20that\x20can\x20be\x20sent\x20back\x20to\x20th\ + e\x20service\x20provider\x20for\x20debugging.\n\n\x0f\n\x05\x04\x05\x02\ + \x01\x04\x12\x06\x90\x01\x02\x8c\x01\x18\n\r\n\x05\x04\x05\x02\x01\x05\ + \x12\x04\x90\x01\x02\x08\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\x90\x01\t\ + \x15\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\x90\x01\x18\x19\n>\n\x02\x04\ + \x06\x12\x06\x94\x01\0\xa8\x01\x01\x1a0\x20Describes\x20the\x20resource\ + \x20that\x20is\x20being\x20accessed.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\ + \x94\x01\x08\x14\n\xdb\x01\n\x04\x04\x06\x02\0\x12\x04\x98\x01\x02\x1b\ + \x1a\xcc\x01\x20A\x20name\x20for\x20the\x20type\x20of\x20resource\x20bei\ + ng\x20accessed,\x20e.g.\x20\"sql\x20table\",\n\x20\"cloud\x20storage\x20\ + bucket\",\x20\"file\",\x20\"Google\x20calendar\";\x20or\x20the\x20type\ + \x20URL\n\x20of\x20the\x20resource:\x20e.g.\x20\"type.googleapis.com/goo\ + gle.pubsub.v1.Topic\".\n\n\x0f\n\x05\x04\x06\x02\0\x04\x12\x06\x98\x01\ + \x02\x94\x01\x16\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\x98\x01\x02\x08\n\r\ + \n\x05\x04\x06\x02\0\x01\x12\x04\x98\x01\t\x16\n\r\n\x05\x04\x06\x02\0\ + \x03\x12\x04\x98\x01\x19\x1a\n\xf6\x01\n\x04\x04\x06\x02\x01\x12\x04\x9d\ + \x01\x02\x1b\x1a\xe7\x01\x20The\x20name\x20of\x20the\x20resource\x20bein\ + g\x20accessed.\x20\x20For\x20example,\x20a\x20shared\x20calendar\n\x20na\ + me:\x20\"example.com_4fghdhgsrgh@group.calendar.google.com\",\x20if\x20t\ + he\x20current\n\x20error\x20is\x20[google.rpc.Code.PERMISSION_DENIED][go\ + ogle.rpc.Code.PERMISSION_DENIED].\n\n\x0f\n\x05\x04\x06\x02\x01\x04\x12\ + \x06\x9d\x01\x02\x98\x01\x1b\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\x9d\ + \x01\x02\x08\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\x9d\x01\t\x16\n\r\n\ + \x05\x04\x06\x02\x01\x03\x12\x04\x9d\x01\x19\x1a\n\x85\x01\n\x04\x04\x06\ + \x02\x02\x12\x04\xa2\x01\x02\x13\x1aw\x20The\x20owner\x20of\x20the\x20re\ + source\x20(optional).\n\x20For\x20example,\x20\"user:\"\ + \x20or\x20\"project:\".\n\n\x0f\ + \n\x05\x04\x06\x02\x02\x04\x12\x06\xa2\x01\x02\x9d\x01\x1b\n\r\n\x05\x04\ + \x06\x02\x02\x05\x12\x04\xa2\x01\x02\x08\n\r\n\x05\x04\x06\x02\x02\x01\ + \x12\x04\xa2\x01\t\x0e\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\xa2\x01\x11\ + \x12\n\xc0\x01\n\x04\x04\x06\x02\x03\x12\x04\xa7\x01\x02\x19\x1a\xb1\x01\ + \x20Describes\x20what\x20error\x20is\x20encountered\x20when\x20accessing\ + \x20this\x20resource.\n\x20For\x20example,\x20updating\x20a\x20cloud\x20\ + project\x20may\x20require\x20the\x20`writer`\x20permission\n\x20on\x20th\ + e\x20developer\x20console\x20project.\n\n\x0f\n\x05\x04\x06\x02\x03\x04\ + \x12\x06\xa7\x01\x02\xa2\x01\x13\n\r\n\x05\x04\x06\x02\x03\x05\x12\x04\ + \xa7\x01\x02\x08\n\r\n\x05\x04\x06\x02\x03\x01\x12\x04\xa7\x01\t\x14\n\r\ + \n\x05\x04\x06\x02\x03\x03\x12\x04\xa7\x01\x17\x18\n\xba\x02\n\x02\x04\ + \x07\x12\x06\xaf\x01\0\xbb\x01\x01\x1a\xab\x02\x20Provides\x20links\x20t\ + o\x20documentation\x20or\x20for\x20performing\x20an\x20out\x20of\x20band\ + \x20action.\n\n\x20For\x20example,\x20if\x20a\x20quota\x20check\x20faile\ + d\x20with\x20an\x20error\x20indicating\x20the\x20calling\n\x20project\ + \x20hasn't\x20enabled\x20the\x20accessed\x20service,\x20this\x20can\x20c\ + ontain\x20a\x20URL\x20pointing\n\x20directly\x20to\x20the\x20right\x20pl\ + ace\x20in\x20the\x20developer\x20console\x20to\x20flip\x20the\x20bit.\n\ + \n\x0b\n\x03\x04\x07\x01\x12\x04\xaf\x01\x08\x0c\n'\n\x04\x04\x07\x03\0\ + \x12\x06\xb1\x01\x02\xb7\x01\x03\x1a\x17\x20Describes\x20a\x20URL\x20lin\ + k.\n\n\r\n\x05\x04\x07\x03\0\x01\x12\x04\xb1\x01\n\x0e\n1\n\x06\x04\x07\ + \x03\0\x02\0\x12\x04\xb3\x01\x04\x1b\x1a!\x20Describes\x20what\x20the\ + \x20link\x20offers.\n\n\x11\n\x07\x04\x07\x03\0\x02\0\x04\x12\x06\xb3\ + \x01\x04\xb1\x01\x10\n\x0f\n\x07\x04\x07\x03\0\x02\0\x05\x12\x04\xb3\x01\ + \x04\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x01\x12\x04\xb3\x01\x0b\x16\n\x0f\ + \n\x07\x04\x07\x03\0\x02\0\x03\x12\x04\xb3\x01\x19\x1a\n&\n\x06\x04\x07\ + \x03\0\x02\x01\x12\x04\xb6\x01\x04\x13\x1a\x16\x20The\x20URL\x20of\x20th\ + e\x20link.\n\n\x11\n\x07\x04\x07\x03\0\x02\x01\x04\x12\x06\xb6\x01\x04\ + \xb3\x01\x1b\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x05\x12\x04\xb6\x01\x04\n\ + \n\x0f\n\x07\x04\x07\x03\0\x02\x01\x01\x12\x04\xb6\x01\x0b\x0e\n\x0f\n\ + \x07\x04\x07\x03\0\x02\x01\x03\x12\x04\xb6\x01\x11\x12\nX\n\x04\x04\x07\ + \x02\0\x12\x04\xba\x01\x02\x1a\x1aJ\x20URL(s)\x20pointing\x20to\x20addit\ + ional\x20information\x20on\x20handling\x20the\x20current\x20error.\n\n\r\ + \n\x05\x04\x07\x02\0\x04\x12\x04\xba\x01\x02\n\n\r\n\x05\x04\x07\x02\0\ + \x06\x12\x04\xba\x01\x0b\x0f\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xba\x01\ + \x10\x15\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xba\x01\x18\x19\n}\n\x02\ + \x04\x08\x12\x06\xbf\x01\0\xc7\x01\x01\x1ao\x20Provides\x20a\x20localize\ + d\x20error\x20message\x20that\x20is\x20safe\x20to\x20return\x20to\x20the\ + \x20user\n\x20which\x20can\x20be\x20attached\x20to\x20an\x20RPC\x20error\ + .\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xbf\x01\x08\x18\n\x9e\x01\n\x04\x04\ + \x08\x02\0\x12\x04\xc3\x01\x02\x14\x1a\x8f\x01\x20The\x20locale\x20used\ + \x20following\x20the\x20specification\x20defined\x20at\n\x20http://www.r\ + fc-editor.org/rfc/bcp/bcp47.txt.\n\x20Examples\x20are:\x20\"en-US\",\x20\ + \"fr-CH\",\x20\"es-MX\"\n\n\x0f\n\x05\x04\x08\x02\0\x04\x12\x06\xc3\x01\ + \x02\xbf\x01\x1a\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\xc3\x01\x02\x08\n\r\ + \n\x05\x04\x08\x02\0\x01\x12\x04\xc3\x01\t\x0f\n\r\n\x05\x04\x08\x02\0\ + \x03\x12\x04\xc3\x01\x12\x13\n@\n\x04\x04\x08\x02\x01\x12\x04\xc6\x01\ + \x02\x15\x1a2\x20The\x20localized\x20error\x20message\x20in\x20the\x20ab\ + ove\x20locale.\n\n\x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\xc6\x01\x02\xc3\ + \x01\x14\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xc6\x01\x02\x08\n\r\n\x05\ + \x04\x08\x02\x01\x01\x12\x04\xc6\x01\t\x10\n\r\n\x05\x04\x08\x02\x01\x03\ + \x12\x04\xc6\x01\x13\x14b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/mod.rs new file mode 100644 index 00000000..db608abc --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/mod.rs @@ -0,0 +1,3 @@ +pub mod code; +pub mod error_details; +pub mod status; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/status.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/status.rs new file mode 100644 index 00000000..1745d7d2 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/rpc/status.rs @@ -0,0 +1,397 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/rpc/status.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Status { + // message fields + pub code: i32, + pub message: ::std::string::String, + pub details: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Status { + fn default() -> &'a Status { + ::default_instance() + } +} + +impl Status { + pub fn new() -> Status { + ::std::default::Default::default() + } + + // int32 code = 1; + + + pub fn get_code(&self) -> i32 { + self.code + } + pub fn clear_code(&mut self) { + self.code = 0; + } + + // Param is passed by value, moved + pub fn set_code(&mut self, v: i32) { + self.code = v; + } + + // string message = 2; + + + pub fn get_message(&self) -> &str { + &self.message + } + pub fn clear_message(&mut self) { + self.message.clear(); + } + + // Param is passed by value, moved + pub fn set_message(&mut self, v: ::std::string::String) { + self.message = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_message(&mut self) -> &mut ::std::string::String { + &mut self.message + } + + // Take field + pub fn take_message(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.message, ::std::string::String::new()) + } + + // repeated .google.protobuf.Any details = 3; + + + pub fn get_details(&self) -> &[::protobuf::well_known_types::Any] { + &self.details + } + pub fn clear_details(&mut self) { + self.details.clear(); + } + + // Param is passed by value, moved + pub fn set_details(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Any>) { + self.details = v; + } + + // Mutable pointer to the field. + pub fn mut_details(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Any> { + &mut self.details + } + + // Take field + pub fn take_details(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Any> { + ::std::mem::replace(&mut self.details, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Status { + fn is_initialized(&self) -> bool { + for v in &self.details { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.code = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.details)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.code != 0 { + my_size += ::protobuf::rt::value_size(1, self.code, ::protobuf::wire_format::WireTypeVarint); + } + if !self.message.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.message); + } + for value in &self.details { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.code != 0 { + os.write_int32(1, self.code)?; + } + if !self.message.is_empty() { + os.write_string(2, &self.message)?; + } + for v in &self.details { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Status { + Status::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "code", + |m: &Status| { &m.code }, + |m: &mut Status| { &mut m.code }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "message", + |m: &Status| { &m.message }, + |m: &mut Status| { &mut m.message }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>( + "details", + |m: &Status| { &m.details }, + |m: &mut Status| { &mut m.details }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Status", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Status { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Status, + }; + unsafe { + instance.get(Status::new) + } + } +} + +impl ::protobuf::Clear for Status { + fn clear(&mut self) { + self.code = 0; + self.message.clear(); + self.details.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Status { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Status { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x17google/rpc/status.proto\x12\ngoogle.rpc\x1a\x19google/protobuf/any\ + .proto\"f\n\x06Status\x12\x12\n\x04code\x18\x01\x20\x01(\x05R\x04code\ + \x12\x18\n\x07message\x18\x02\x20\x01(\tR\x07message\x12.\n\x07details\ + \x18\x03\x20\x03(\x0b2\x14.google.protobuf.AnyR\x07detailsB^\n\x0ecom.go\ + ogle.rpcB\x0bStatusProtoP\x01Z7google.golang.org/genproto/googleapis/rpc\ + /status;status\xa2\x02\x03RPCJ\x9b\x1e\n\x06\x12\x04\x0e\0[\x01\n\xbd\ + \x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202017\x20Google\ + \x20Inc.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Versio\ + n\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\ + \x20file\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20Y\ + ou\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\ + \x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\ + \x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20w\ + riting,\x20software\n\x20distributed\x20under\x20the\x20License\x20is\ + \x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WA\ + RRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\ + \x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\ + \x20language\x20governing\x20permissions\x20and\n\x20limitations\x20unde\ + r\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x13\n\t\n\x02\x03\0\ + \x12\x03\x12\0#\n\x08\n\x01\x08\x12\x03\x14\0N\n\t\n\x02\x08\x0b\x12\x03\ + \x14\0N\n\x08\n\x01\x08\x12\x03\x15\0\"\n\t\n\x02\x08\n\x12\x03\x15\0\"\ + \n\x08\n\x01\x08\x12\x03\x16\0,\n\t\n\x02\x08\x08\x12\x03\x16\0,\n\x08\n\ + \x01\x08\x12\x03\x17\0'\n\t\n\x02\x08\x01\x12\x03\x17\0'\n\x08\n\x01\x08\ + \x12\x03\x18\0!\n\t\n\x02\x08$\x12\x03\x18\0!\n\xcd\x13\n\x02\x04\0\x12\ + \x04O\0[\x01\x1a\xc0\x13\x20The\x20`Status`\x20type\x20defines\x20a\x20l\ + ogical\x20error\x20model\x20that\x20is\x20suitable\x20for\x20different\n\ + \x20programming\x20environments,\x20including\x20REST\x20APIs\x20and\x20\ + RPC\x20APIs.\x20It\x20is\x20used\x20by\n\x20[gRPC](https://github.com/gr\ + pc).\x20The\x20error\x20model\x20is\x20designed\x20to\x20be:\n\n\x20-\ + \x20Simple\x20to\x20use\x20and\x20understand\x20for\x20most\x20users\n\ + \x20-\x20Flexible\x20enough\x20to\x20meet\x20unexpected\x20needs\n\n\x20\ + #\x20Overview\n\n\x20The\x20`Status`\x20message\x20contains\x20three\x20\ + pieces\x20of\x20data:\x20error\x20code,\x20error\x20message,\n\x20and\ + \x20error\x20details.\x20The\x20error\x20code\x20should\x20be\x20an\x20e\ + num\x20value\x20of\n\x20[google.rpc.Code][google.rpc.Code],\x20but\x20it\ + \x20may\x20accept\x20additional\x20error\x20codes\x20if\x20needed.\x20\ + \x20The\n\x20error\x20message\x20should\x20be\x20a\x20developer-facing\ + \x20English\x20message\x20that\x20helps\n\x20developers\x20*understand*\ + \x20and\x20*resolve*\x20the\x20error.\x20If\x20a\x20localized\x20user-fa\ + cing\n\x20error\x20message\x20is\x20needed,\x20put\x20the\x20localized\ + \x20message\x20in\x20the\x20error\x20details\x20or\n\x20localize\x20it\ + \x20in\x20the\x20client.\x20The\x20optional\x20error\x20details\x20may\ + \x20contain\x20arbitrary\n\x20information\x20about\x20the\x20error.\x20T\ + here\x20is\x20a\x20predefined\x20set\x20of\x20error\x20detail\x20types\n\ + \x20in\x20the\x20package\x20`google.rpc`\x20that\x20can\x20be\x20used\ + \x20for\x20common\x20error\x20conditions.\n\n\x20#\x20Language\x20mappin\ + g\n\n\x20The\x20`Status`\x20message\x20is\x20the\x20logical\x20represent\ + ation\x20of\x20the\x20error\x20model,\x20but\x20it\n\x20is\x20not\x20nec\ + essarily\x20the\x20actual\x20wire\x20format.\x20When\x20the\x20`Status`\ + \x20message\x20is\n\x20exposed\x20in\x20different\x20client\x20libraries\ + \x20and\x20different\x20wire\x20protocols,\x20it\x20can\x20be\n\x20mappe\ + d\x20differently.\x20For\x20example,\x20it\x20will\x20likely\x20be\x20ma\ + pped\x20to\x20some\x20exceptions\n\x20in\x20Java,\x20but\x20more\x20like\ + ly\x20mapped\x20to\x20some\x20error\x20codes\x20in\x20C.\n\n\x20#\x20Oth\ + er\x20uses\n\n\x20The\x20error\x20model\x20and\x20the\x20`Status`\x20mes\ + sage\x20can\x20be\x20used\x20in\x20a\x20variety\x20of\n\x20environments,\ + \x20either\x20with\x20or\x20without\x20APIs,\x20to\x20provide\x20a\n\x20\ + consistent\x20developer\x20experience\x20across\x20different\x20environm\ + ents.\n\n\x20Example\x20uses\x20of\x20this\x20error\x20model\x20include:\ + \n\n\x20-\x20Partial\x20errors.\x20If\x20a\x20service\x20needs\x20to\x20\ + return\x20partial\x20errors\x20to\x20the\x20client,\n\x20\x20\x20\x20\ + \x20it\x20may\x20embed\x20the\x20`Status`\x20in\x20the\x20normal\x20resp\ + onse\x20to\x20indicate\x20the\x20partial\n\x20\x20\x20\x20\x20errors.\n\ + \n\x20-\x20Workflow\x20errors.\x20A\x20typical\x20workflow\x20has\x20mul\ + tiple\x20steps.\x20Each\x20step\x20may\n\x20\x20\x20\x20\x20have\x20a\ + \x20`Status`\x20message\x20for\x20error\x20reporting.\n\n\x20-\x20Batch\ + \x20operations.\x20If\x20a\x20client\x20uses\x20batch\x20request\x20and\ + \x20batch\x20response,\x20the\n\x20\x20\x20\x20\x20`Status`\x20message\ + \x20should\x20be\x20used\x20directly\x20inside\x20batch\x20response,\x20\ + one\x20for\n\x20\x20\x20\x20\x20each\x20error\x20sub-response.\n\n\x20-\ + \x20Asynchronous\x20operations.\x20If\x20an\x20API\x20call\x20embeds\x20\ + asynchronous\x20operation\n\x20\x20\x20\x20\x20results\x20in\x20its\x20r\ + esponse,\x20the\x20status\x20of\x20those\x20operations\x20should\x20be\n\ + \x20\x20\x20\x20\x20represented\x20directly\x20using\x20the\x20`Status`\ + \x20message.\n\n\x20-\x20Logging.\x20If\x20some\x20API\x20errors\x20are\ + \x20stored\x20in\x20logs,\x20the\x20message\x20`Status`\x20could\n\x20\ + \x20\x20\x20\x20be\x20used\x20directly\x20after\x20any\x20stripping\x20n\ + eeded\x20for\x20security/privacy\x20reasons.\n\n\n\n\x03\x04\0\x01\x12\ + \x03O\x08\x0e\nd\n\x04\x04\0\x02\0\x12\x03Q\x02\x11\x1aW\x20The\x20statu\ + s\x20code,\x20which\x20should\x20be\x20an\x20enum\x20value\x20of\x20[goo\ + gle.rpc.Code][google.rpc.Code].\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04Q\x02\ + O\x10\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03Q\x02\x07\n\x0c\n\x05\x04\0\x02\ + \0\x01\x12\x03Q\x08\x0c\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03Q\x0f\x10\n\ + \xeb\x01\n\x04\x04\0\x02\x01\x12\x03V\x02\x15\x1a\xdd\x01\x20A\x20develo\ + per-facing\x20error\x20message,\x20which\x20should\x20be\x20in\x20Englis\ + h.\x20Any\n\x20user-facing\x20error\x20message\x20should\x20be\x20locali\ + zed\x20and\x20sent\x20in\x20the\n\x20[google.rpc.Status.details][google.\ + rpc.Status.details]\x20field,\x20or\x20localized\x20by\x20the\x20client.\ + \n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04V\x02Q\x11\n\x0c\n\x05\x04\0\x02\ + \x01\x05\x12\x03V\x02\x08\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03V\t\x10\n\ + \x0c\n\x05\x04\0\x02\x01\x03\x12\x03V\x13\x14\ny\n\x04\x04\0\x02\x02\x12\ + \x03Z\x02+\x1al\x20A\x20list\x20of\x20messages\x20that\x20carry\x20the\ + \x20error\x20details.\x20\x20There\x20is\x20a\x20common\x20set\x20of\n\ + \x20message\x20types\x20for\x20APIs\x20to\x20use.\n\n\x0c\n\x05\x04\0\ + \x02\x02\x04\x12\x03Z\x02\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03Z\x0b\ + \x1e\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03Z\x1f&\n\x0c\n\x05\x04\0\x02\ + \x02\x03\x12\x03Z)*b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/mod.rs new file mode 100644 index 00000000..a3a6d96c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/mod.rs new file mode 100644 index 00000000..b4371f94 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/mod.rs @@ -0,0 +1,8 @@ +pub mod spanner_database_admin; +pub mod spanner_database_admin_grpc; + +pub(crate) use crate::{ + empty, + iam::v1::{iam_policy, policy}, + longrunning::operations, +}; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin.rs new file mode 100644 index 00000000..9bad1acd --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin.rs @@ -0,0 +1,2757 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/admin/database/v1/spanner_database_admin.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Database { + // message fields + pub name: ::std::string::String, + pub state: Database_State, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Database { + fn default() -> &'a Database { + ::default_instance() + } +} + +impl Database { + pub fn new() -> Database { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.spanner.admin.database.v1.Database.State state = 2; + + + pub fn get_state(&self) -> Database_State { + self.state + } + pub fn clear_state(&mut self) { + self.state = Database_State::STATE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: Database_State) { + self.state = v; + } +} + +impl ::protobuf::Message for Database { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 2, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if self.state != Database_State::STATE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(2, self.state); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if self.state != Database_State::STATE_UNSPECIFIED { + os.write_enum(2, self.state.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Database { + Database::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Database| { &m.name }, + |m: &mut Database| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "state", + |m: &Database| { &m.state }, + |m: &mut Database| { &mut m.state }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Database", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Database { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Database, + }; + unsafe { + instance.get(Database::new) + } + } +} + +impl ::protobuf::Clear for Database { + fn clear(&mut self) { + self.name.clear(); + self.state = Database_State::STATE_UNSPECIFIED; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Database { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Database { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Database_State { + STATE_UNSPECIFIED = 0, + CREATING = 1, + READY = 2, +} + +impl ::protobuf::ProtobufEnum for Database_State { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Database_State::STATE_UNSPECIFIED), + 1 => ::std::option::Option::Some(Database_State::CREATING), + 2 => ::std::option::Option::Some(Database_State::READY), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Database_State] = &[ + Database_State::STATE_UNSPECIFIED, + Database_State::CREATING, + Database_State::READY, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Database_State", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Database_State { +} + +impl ::std::default::Default for Database_State { + fn default() -> Self { + Database_State::STATE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for Database_State { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListDatabasesRequest { + // message fields + pub parent: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListDatabasesRequest { + fn default() -> &'a ListDatabasesRequest { + ::default_instance() + } +} + +impl ListDatabasesRequest { + pub fn new() -> ListDatabasesRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // int32 page_size = 3; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 4; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListDatabasesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(3, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.page_size != 0 { + os.write_int32(3, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(4, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListDatabasesRequest { + ListDatabasesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListDatabasesRequest| { &m.parent }, + |m: &mut ListDatabasesRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListDatabasesRequest| { &m.page_size }, + |m: &mut ListDatabasesRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListDatabasesRequest| { &m.page_token }, + |m: &mut ListDatabasesRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListDatabasesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListDatabasesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListDatabasesRequest, + }; + unsafe { + instance.get(ListDatabasesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListDatabasesRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListDatabasesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListDatabasesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListDatabasesResponse { + // message fields + pub databases: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListDatabasesResponse { + fn default() -> &'a ListDatabasesResponse { + ::default_instance() + } +} + +impl ListDatabasesResponse { + pub fn new() -> ListDatabasesResponse { + ::std::default::Default::default() + } + + // repeated .google.spanner.admin.database.v1.Database databases = 1; + + + pub fn get_databases(&self) -> &[Database] { + &self.databases + } + pub fn clear_databases(&mut self) { + self.databases.clear(); + } + + // Param is passed by value, moved + pub fn set_databases(&mut self, v: ::protobuf::RepeatedField) { + self.databases = v; + } + + // Mutable pointer to the field. + pub fn mut_databases(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.databases + } + + // Take field + pub fn take_databases(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.databases, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListDatabasesResponse { + fn is_initialized(&self) -> bool { + for v in &self.databases { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.databases)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.databases { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.databases { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListDatabasesResponse { + ListDatabasesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "databases", + |m: &ListDatabasesResponse| { &m.databases }, + |m: &mut ListDatabasesResponse| { &mut m.databases }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListDatabasesResponse| { &m.next_page_token }, + |m: &mut ListDatabasesResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListDatabasesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListDatabasesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListDatabasesResponse, + }; + unsafe { + instance.get(ListDatabasesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListDatabasesResponse { + fn clear(&mut self) { + self.databases.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListDatabasesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListDatabasesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateDatabaseRequest { + // message fields + pub parent: ::std::string::String, + pub create_statement: ::std::string::String, + pub extra_statements: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateDatabaseRequest { + fn default() -> &'a CreateDatabaseRequest { + ::default_instance() + } +} + +impl CreateDatabaseRequest { + pub fn new() -> CreateDatabaseRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string create_statement = 2; + + + pub fn get_create_statement(&self) -> &str { + &self.create_statement + } + pub fn clear_create_statement(&mut self) { + self.create_statement.clear(); + } + + // Param is passed by value, moved + pub fn set_create_statement(&mut self, v: ::std::string::String) { + self.create_statement = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_create_statement(&mut self) -> &mut ::std::string::String { + &mut self.create_statement + } + + // Take field + pub fn take_create_statement(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.create_statement, ::std::string::String::new()) + } + + // repeated string extra_statements = 3; + + + pub fn get_extra_statements(&self) -> &[::std::string::String] { + &self.extra_statements + } + pub fn clear_extra_statements(&mut self) { + self.extra_statements.clear(); + } + + // Param is passed by value, moved + pub fn set_extra_statements(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.extra_statements = v; + } + + // Mutable pointer to the field. + pub fn mut_extra_statements(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.extra_statements + } + + // Take field + pub fn take_extra_statements(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.extra_statements, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CreateDatabaseRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.create_statement)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.extra_statements)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.create_statement.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.create_statement); + } + for value in &self.extra_statements { + my_size += ::protobuf::rt::string_size(3, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.create_statement.is_empty() { + os.write_string(2, &self.create_statement)?; + } + for v in &self.extra_statements { + os.write_string(3, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateDatabaseRequest { + CreateDatabaseRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateDatabaseRequest| { &m.parent }, + |m: &mut CreateDatabaseRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "create_statement", + |m: &CreateDatabaseRequest| { &m.create_statement }, + |m: &mut CreateDatabaseRequest| { &mut m.create_statement }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "extra_statements", + |m: &CreateDatabaseRequest| { &m.extra_statements }, + |m: &mut CreateDatabaseRequest| { &mut m.extra_statements }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateDatabaseRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateDatabaseRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateDatabaseRequest, + }; + unsafe { + instance.get(CreateDatabaseRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateDatabaseRequest { + fn clear(&mut self) { + self.parent.clear(); + self.create_statement.clear(); + self.extra_statements.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateDatabaseRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateDatabaseRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateDatabaseMetadata { + // message fields + pub database: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateDatabaseMetadata { + fn default() -> &'a CreateDatabaseMetadata { + ::default_instance() + } +} + +impl CreateDatabaseMetadata { + pub fn new() -> CreateDatabaseMetadata { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for CreateDatabaseMetadata { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateDatabaseMetadata { + CreateDatabaseMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &CreateDatabaseMetadata| { &m.database }, + |m: &mut CreateDatabaseMetadata| { &mut m.database }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateDatabaseMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateDatabaseMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateDatabaseMetadata, + }; + unsafe { + instance.get(CreateDatabaseMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateDatabaseMetadata { + fn clear(&mut self) { + self.database.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateDatabaseMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateDatabaseMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetDatabaseRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetDatabaseRequest { + fn default() -> &'a GetDatabaseRequest { + ::default_instance() + } +} + +impl GetDatabaseRequest { + pub fn new() -> GetDatabaseRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetDatabaseRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetDatabaseRequest { + GetDatabaseRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetDatabaseRequest| { &m.name }, + |m: &mut GetDatabaseRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetDatabaseRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetDatabaseRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetDatabaseRequest, + }; + unsafe { + instance.get(GetDatabaseRequest::new) + } + } +} + +impl ::protobuf::Clear for GetDatabaseRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetDatabaseRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetDatabaseRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateDatabaseDdlRequest { + // message fields + pub database: ::std::string::String, + pub statements: ::protobuf::RepeatedField<::std::string::String>, + pub operation_id: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateDatabaseDdlRequest { + fn default() -> &'a UpdateDatabaseDdlRequest { + ::default_instance() + } +} + +impl UpdateDatabaseDdlRequest { + pub fn new() -> UpdateDatabaseDdlRequest { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } + + // repeated string statements = 2; + + + pub fn get_statements(&self) -> &[::std::string::String] { + &self.statements + } + pub fn clear_statements(&mut self) { + self.statements.clear(); + } + + // Param is passed by value, moved + pub fn set_statements(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.statements = v; + } + + // Mutable pointer to the field. + pub fn mut_statements(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.statements + } + + // Take field + pub fn take_statements(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.statements, ::protobuf::RepeatedField::new()) + } + + // string operation_id = 3; + + + pub fn get_operation_id(&self) -> &str { + &self.operation_id + } + pub fn clear_operation_id(&mut self) { + self.operation_id.clear(); + } + + // Param is passed by value, moved + pub fn set_operation_id(&mut self, v: ::std::string::String) { + self.operation_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_operation_id(&mut self) -> &mut ::std::string::String { + &mut self.operation_id + } + + // Take field + pub fn take_operation_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.operation_id, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for UpdateDatabaseDdlRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.statements)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.operation_id)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + for value in &self.statements { + my_size += ::protobuf::rt::string_size(2, &value); + }; + if !self.operation_id.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.operation_id); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + for v in &self.statements { + os.write_string(2, &v)?; + }; + if !self.operation_id.is_empty() { + os.write_string(3, &self.operation_id)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateDatabaseDdlRequest { + UpdateDatabaseDdlRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &UpdateDatabaseDdlRequest| { &m.database }, + |m: &mut UpdateDatabaseDdlRequest| { &mut m.database }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "statements", + |m: &UpdateDatabaseDdlRequest| { &m.statements }, + |m: &mut UpdateDatabaseDdlRequest| { &mut m.statements }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "operation_id", + |m: &UpdateDatabaseDdlRequest| { &m.operation_id }, + |m: &mut UpdateDatabaseDdlRequest| { &mut m.operation_id }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateDatabaseDdlRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateDatabaseDdlRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateDatabaseDdlRequest, + }; + unsafe { + instance.get(UpdateDatabaseDdlRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateDatabaseDdlRequest { + fn clear(&mut self) { + self.database.clear(); + self.statements.clear(); + self.operation_id.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateDatabaseDdlRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateDatabaseDdlRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateDatabaseDdlMetadata { + // message fields + pub database: ::std::string::String, + pub statements: ::protobuf::RepeatedField<::std::string::String>, + pub commit_timestamps: ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateDatabaseDdlMetadata { + fn default() -> &'a UpdateDatabaseDdlMetadata { + ::default_instance() + } +} + +impl UpdateDatabaseDdlMetadata { + pub fn new() -> UpdateDatabaseDdlMetadata { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } + + // repeated string statements = 2; + + + pub fn get_statements(&self) -> &[::std::string::String] { + &self.statements + } + pub fn clear_statements(&mut self) { + self.statements.clear(); + } + + // Param is passed by value, moved + pub fn set_statements(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.statements = v; + } + + // Mutable pointer to the field. + pub fn mut_statements(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.statements + } + + // Take field + pub fn take_statements(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.statements, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.Timestamp commit_timestamps = 3; + + + pub fn get_commit_timestamps(&self) -> &[::protobuf::well_known_types::Timestamp] { + &self.commit_timestamps + } + pub fn clear_commit_timestamps(&mut self) { + self.commit_timestamps.clear(); + } + + // Param is passed by value, moved + pub fn set_commit_timestamps(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp>) { + self.commit_timestamps = v; + } + + // Mutable pointer to the field. + pub fn mut_commit_timestamps(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp> { + &mut self.commit_timestamps + } + + // Take field + pub fn take_commit_timestamps(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp> { + ::std::mem::replace(&mut self.commit_timestamps, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for UpdateDatabaseDdlMetadata { + fn is_initialized(&self) -> bool { + for v in &self.commit_timestamps { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.statements)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.commit_timestamps)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + for value in &self.statements { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.commit_timestamps { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + for v in &self.statements { + os.write_string(2, &v)?; + }; + for v in &self.commit_timestamps { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateDatabaseDdlMetadata { + UpdateDatabaseDdlMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &UpdateDatabaseDdlMetadata| { &m.database }, + |m: &mut UpdateDatabaseDdlMetadata| { &mut m.database }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "statements", + |m: &UpdateDatabaseDdlMetadata| { &m.statements }, + |m: &mut UpdateDatabaseDdlMetadata| { &mut m.statements }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "commit_timestamps", + |m: &UpdateDatabaseDdlMetadata| { &m.commit_timestamps }, + |m: &mut UpdateDatabaseDdlMetadata| { &mut m.commit_timestamps }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateDatabaseDdlMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateDatabaseDdlMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateDatabaseDdlMetadata, + }; + unsafe { + instance.get(UpdateDatabaseDdlMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateDatabaseDdlMetadata { + fn clear(&mut self) { + self.database.clear(); + self.statements.clear(); + self.commit_timestamps.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateDatabaseDdlMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateDatabaseDdlMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DropDatabaseRequest { + // message fields + pub database: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DropDatabaseRequest { + fn default() -> &'a DropDatabaseRequest { + ::default_instance() + } +} + +impl DropDatabaseRequest { + pub fn new() -> DropDatabaseRequest { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DropDatabaseRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DropDatabaseRequest { + DropDatabaseRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &DropDatabaseRequest| { &m.database }, + |m: &mut DropDatabaseRequest| { &mut m.database }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DropDatabaseRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DropDatabaseRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DropDatabaseRequest, + }; + unsafe { + instance.get(DropDatabaseRequest::new) + } + } +} + +impl ::protobuf::Clear for DropDatabaseRequest { + fn clear(&mut self) { + self.database.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DropDatabaseRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DropDatabaseRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetDatabaseDdlRequest { + // message fields + pub database: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetDatabaseDdlRequest { + fn default() -> &'a GetDatabaseDdlRequest { + ::default_instance() + } +} + +impl GetDatabaseDdlRequest { + pub fn new() -> GetDatabaseDdlRequest { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetDatabaseDdlRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetDatabaseDdlRequest { + GetDatabaseDdlRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &GetDatabaseDdlRequest| { &m.database }, + |m: &mut GetDatabaseDdlRequest| { &mut m.database }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetDatabaseDdlRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetDatabaseDdlRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetDatabaseDdlRequest, + }; + unsafe { + instance.get(GetDatabaseDdlRequest::new) + } + } +} + +impl ::protobuf::Clear for GetDatabaseDdlRequest { + fn clear(&mut self) { + self.database.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetDatabaseDdlRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetDatabaseDdlRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetDatabaseDdlResponse { + // message fields + pub statements: ::protobuf::RepeatedField<::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetDatabaseDdlResponse { + fn default() -> &'a GetDatabaseDdlResponse { + ::default_instance() + } +} + +impl GetDatabaseDdlResponse { + pub fn new() -> GetDatabaseDdlResponse { + ::std::default::Default::default() + } + + // repeated string statements = 1; + + + pub fn get_statements(&self) -> &[::std::string::String] { + &self.statements + } + pub fn clear_statements(&mut self) { + self.statements.clear(); + } + + // Param is passed by value, moved + pub fn set_statements(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.statements = v; + } + + // Mutable pointer to the field. + pub fn mut_statements(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.statements + } + + // Take field + pub fn take_statements(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.statements, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GetDatabaseDdlResponse { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.statements)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.statements { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.statements { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetDatabaseDdlResponse { + GetDatabaseDdlResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "statements", + |m: &GetDatabaseDdlResponse| { &m.statements }, + |m: &mut GetDatabaseDdlResponse| { &mut m.statements }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetDatabaseDdlResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetDatabaseDdlResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetDatabaseDdlResponse, + }; + unsafe { + instance.get(GetDatabaseDdlResponse::new) + } + } +} + +impl ::protobuf::Clear for GetDatabaseDdlResponse { + fn clear(&mut self) { + self.statements.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetDatabaseDdlResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetDatabaseDdlResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n=google/spanner/admin/database/v1/spanner_database_admin.proto\x12\x20\ + google.spanner.admin.database.v1\x1a\x1cgoogle/api/annotations.proto\x1a\ + \x1egoogle/iam/v1/iam_policy.proto\x1a\x1agoogle/iam/v1/policy.proto\x1a\ + #google/longrunning/operations.proto\x1a\x1bgoogle/protobuf/empty.proto\ + \x1a\x1fgoogle/protobuf/timestamp.proto\"\x9f\x01\n\x08Database\x12\x12\ + \n\x04name\x18\x01\x20\x01(\tR\x04name\x12F\n\x05state\x18\x02\x20\x01(\ + \x0e20.google.spanner.admin.database.v1.Database.StateR\x05state\"7\n\ + \x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\0\x12\x0c\n\x08CREATING\x10\ + \x01\x12\t\n\x05READY\x10\x02\"j\n\x14ListDatabasesRequest\x12\x16\n\x06\ + parent\x18\x01\x20\x01(\tR\x06parent\x12\x1b\n\tpage_size\x18\x03\x20\ + \x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x04\x20\x01(\tR\tpageTo\ + ken\"\x89\x01\n\x15ListDatabasesResponse\x12H\n\tdatabases\x18\x01\x20\ + \x03(\x0b2*.google.spanner.admin.database.v1.DatabaseR\tdatabases\x12&\n\ + \x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"\x85\x01\n\x15Cr\ + eateDatabaseRequest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\ + \x12)\n\x10create_statement\x18\x02\x20\x01(\tR\x0fcreateStatement\x12)\ + \n\x10extra_statements\x18\x03\x20\x03(\tR\x0fextraStatements\"4\n\x16Cr\ + eateDatabaseMetadata\x12\x1a\n\x08database\x18\x01\x20\x01(\tR\x08databa\ + se\"(\n\x12GetDatabaseRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\ + ame\"y\n\x18UpdateDatabaseDdlRequest\x12\x1a\n\x08database\x18\x01\x20\ + \x01(\tR\x08database\x12\x1e\n\nstatements\x18\x02\x20\x03(\tR\nstatemen\ + ts\x12!\n\x0coperation_id\x18\x03\x20\x01(\tR\x0boperationId\"\xa0\x01\n\ + \x19UpdateDatabaseDdlMetadata\x12\x1a\n\x08database\x18\x01\x20\x01(\tR\ + \x08database\x12\x1e\n\nstatements\x18\x02\x20\x03(\tR\nstatements\x12G\ + \n\x11commit_timestamps\x18\x03\x20\x03(\x0b2\x1a.google.protobuf.Timest\ + ampR\x10commitTimestamps\"1\n\x13DropDatabaseRequest\x12\x1a\n\x08databa\ + se\x18\x01\x20\x01(\tR\x08database\"3\n\x15GetDatabaseDdlRequest\x12\x1a\ + \n\x08database\x18\x01\x20\x01(\tR\x08database\"8\n\x16GetDatabaseDdlRes\ + ponse\x12\x1e\n\nstatements\x18\x01\x20\x03(\tR\nstatements2\x95\x0c\n\r\ + DatabaseAdmin\x12\xb7\x01\n\rListDatabases\x126.google.spanner.admin.dat\ + abase.v1.ListDatabasesRequest\x1a7.google.spanner.admin.database.v1.List\ + DatabasesResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1/{parent=projects/*/ins\ + tances/*}/databases\x12\xa2\x01\n\x0eCreateDatabase\x127.google.spanner.\ + admin.database.v1.CreateDatabaseRequest\x1a\x1d.google.longrunning.Opera\ + tion\"8\x82\xd3\xe4\x93\x022\"-/v1/{parent=projects/*/instances/*}/datab\ + ases:\x01*\x12\xa6\x01\n\x0bGetDatabase\x124.google.spanner.admin.databa\ + se.v1.GetDatabaseRequest\x1a*.google.spanner.admin.database.v1.Database\ + \"5\x82\xd3\xe4\x93\x02/\x12-/v1/{name=projects/*/instances/*/databases/\ + *}\x12\xb0\x01\n\x11UpdateDatabaseDdl\x12:.google.spanner.admin.database\ + .v1.UpdateDatabaseDdlRequest\x1a\x1d.google.longrunning.Operation\"@\x82\ + \xd3\xe4\x93\x02:25/v1/{database=projects/*/instances/*/databases/*}/ddl\ + :\x01*\x12\x98\x01\n\x0cDropDatabase\x125.google.spanner.admin.database.\ + v1.DropDatabaseRequest\x1a\x16.google.protobuf.Empty\"9\x82\xd3\xe4\x93\ + \x023*1/v1/{database=projects/*/instances/*/databases/*}\x12\xc2\x01\n\ + \x0eGetDatabaseDdl\x127.google.spanner.admin.database.v1.GetDatabaseDdlR\ + equest\x1a8.google.spanner.admin.database.v1.GetDatabaseDdlResponse\"=\ + \x82\xd3\xe4\x93\x027\x125/v1/{database=projects/*/instances/*/databases\ + /*}/ddl\x12\x94\x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRe\ + quest\x1a\x15.google.iam.v1.Policy\"I\x82\xd3\xe4\x93\x02C\">/v1/{resour\ + ce=projects/*/instances/*/databases/*}:setIamPolicy:\x01*\x12\x94\x01\n\ + \x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRequest\x1a\x15.google.\ + iam.v1.Policy\"I\x82\xd3\xe4\x93\x02C\">/v1/{resource=projects/*/instanc\ + es/*/databases/*}:getIamPolicy:\x01*\x12\xba\x01\n\x12TestIamPermissions\ + \x12(.google.iam.v1.TestIamPermissionsRequest\x1a).google.iam.v1.TestIam\ + PermissionsResponse\"O\x82\xd3\xe4\x93\x02I\"D/v1/{resource=projects/*/i\ + nstances/*/databases/*}:testIamPermissions:\x01*B\xdf\x01\n$com.google.s\ + panner.admin.database.v1B\x19SpannerDatabaseAdminProtoP\x01ZHgoogle.gola\ + ng.org/genproto/googleapis/spanner/admin/database/v1;database\xaa\x02&Go\ + ogle.Cloud.Spanner.Admin.Database.V1\xca\x02&Google\\Cloud\\Spanner\\Adm\ + in\\Database\\V1J\xa0]\n\x07\x12\x05\x0e\0\xad\x02\x01\n\xbc\x04\n\x01\ + \x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202018\x20Google\x20LLC\n\ + \n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\ + \x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\ + \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\ + y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\ + \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\ + ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\ + \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\ + buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\ + \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\ + \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\ + guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\ + e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0)\n\t\n\x02\x03\0\x12\x03\ + \x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0(\n\t\n\x02\x03\x02\x12\x03\x14\0\ + $\n\t\n\x02\x03\x03\x12\x03\x15\0-\n\t\n\x02\x03\x04\x12\x03\x16\0%\n\t\ + \n\x02\x03\x05\x12\x03\x17\0)\n\x08\n\x01\x08\x12\x03\x19\0C\n\t\n\x02\ + \x08%\x12\x03\x19\0C\n\x08\n\x01\x08\x12\x03\x1a\0_\n\t\n\x02\x08\x0b\ + \x12\x03\x1a\0_\n\x08\n\x01\x08\x12\x03\x1b\0\"\n\t\n\x02\x08\n\x12\x03\ + \x1b\0\"\n\x08\n\x01\x08\x12\x03\x1c\0:\n\t\n\x02\x08\x08\x12\x03\x1c\0:\ + \n\x08\n\x01\x08\x12\x03\x1d\0=\n\t\n\x02\x08\x01\x12\x03\x1d\0=\n\x08\n\ + \x01\x08\x12\x03\x1e\0E\n\t\n\x02\x08)\x12\x03\x1e\0E\n\xc9\x01\n\x02\ + \x06\0\x12\x05&\0\x86\x01\x01\x1a\xbb\x01\x20Cloud\x20Spanner\x20Databas\ + e\x20Admin\x20API\n\n\x20The\x20Cloud\x20Spanner\x20Database\x20Admin\ + \x20API\x20can\x20be\x20used\x20to\x20create,\x20drop,\x20and\n\x20list\ + \x20databases.\x20It\x20also\x20enables\x20updating\x20the\x20schema\x20\ + of\x20pre-existing\n\x20databases.\n\n\n\n\x03\x06\0\x01\x12\x03&\x08\ + \x15\n.\n\x04\x06\0\x02\0\x12\x04(\x02,\x03\x1a\x20\x20Lists\x20Cloud\ + \x20Spanner\x20databases.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03(\x06\x13\ + \n\x0c\n\x05\x06\0\x02\0\x02\x12\x03(\x14(\n\x0c\n\x05\x06\0\x02\0\x03\ + \x12\x03(3H\n\r\n\x05\x06\0\x02\0\x04\x12\x04)\x04+\x06\n\x11\n\t\x06\0\ + \x02\0\x04\xb0\xca\xbc\"\x12\x04)\x04+\x06\n\xc8\x04\n\x04\x06\0\x02\x01\ + \x12\x046\x02;\x03\x1a\xb9\x04\x20Creates\x20a\x20new\x20Cloud\x20Spanne\ + r\x20database\x20and\x20starts\x20to\x20prepare\x20it\x20for\x20serving.\ + \n\x20The\x20returned\x20[long-running\x20operation][google.longrunning.\ + Operation]\x20will\n\x20have\x20a\x20name\x20of\x20the\x20format\x20`/operations/`\x20and\n\x20can\x20be\x20used\ + \x20to\x20track\x20preparation\x20of\x20the\x20database.\x20The\n\x20[me\ + tadata][google.longrunning.Operation.metadata]\x20field\x20type\x20is\n\ + \x20[CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateData\ + baseMetadata].\x20The\n\x20[response][google.longrunning.Operation.respo\ + nse]\x20field\x20type\x20is\n\x20[Database][google.spanner.admin.databas\ + e.v1.Database],\x20if\x20successful.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\ + \x036\x06\x14\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x036\x15*\n\x0c\n\x05\ + \x06\0\x02\x01\x03\x12\x0365Q\n\r\n\x05\x06\0\x02\x01\x04\x12\x047\x04:\ + \x06\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x047\x04:\x06\n;\n\ + \x04\x06\0\x02\x02\x12\x04>\x02B\x03\x1a-\x20Gets\x20the\x20state\x20of\ + \x20a\x20Cloud\x20Spanner\x20database.\n\n\x0c\n\x05\x06\0\x02\x02\x01\ + \x12\x03>\x06\x11\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03>\x12$\n\x0c\n\ + \x05\x06\0\x02\x02\x03\x12\x03>/7\n\r\n\x05\x06\0\x02\x02\x04\x12\x04?\ + \x04A\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04?\x04A\x06\n\ + \x8a\x04\n\x04\x06\0\x02\x03\x12\x04K\x02P\x03\x1a\xfb\x03\x20Updates\ + \x20the\x20schema\x20of\x20a\x20Cloud\x20Spanner\x20database\x20by\n\x20\ + creating/altering/dropping\x20tables,\x20columns,\x20indexes,\x20etc.\ + \x20The\x20returned\n\x20[long-running\x20operation][google.longrunning.\ + Operation]\x20will\x20have\x20a\x20name\x20of\n\x20the\x20format\x20`/operations/`\x20and\x20can\x20be\x20used\x20t\ + o\n\x20track\x20execution\x20of\x20the\x20schema\x20change(s).\x20The\n\ + \x20[metadata][google.longrunning.Operation.metadata]\x20field\x20type\ + \x20is\n\x20[UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1\ + .UpdateDatabaseDdlMetadata].\x20\x20The\x20operation\x20has\x20no\x20res\ + ponse.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03K\x06\x17\n\x0c\n\x05\x06\ + \0\x02\x03\x02\x12\x03K\x180\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03K;W\n\ + \r\n\x05\x06\0\x02\x03\x04\x12\x04L\x04O\x06\n\x11\n\t\x06\0\x02\x03\x04\ + \xb0\xca\xbc\"\x12\x04L\x04O\x06\n=\n\x04\x06\0\x02\x04\x12\x04S\x02W\ + \x03\x1a/\x20Drops\x20(aka\x20deletes)\x20a\x20Cloud\x20Spanner\x20datab\ + ase.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03S\x06\x12\n\x0c\n\x05\x06\0\ + \x02\x04\x02\x12\x03S\x13&\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03S1F\n\r\ + \n\x05\x06\0\x02\x04\x04\x12\x04T\x04V\x06\n\x11\n\t\x06\0\x02\x04\x04\ + \xb0\xca\xbc\"\x12\x04T\x04V\x06\n\xea\x01\n\x04\x06\0\x02\x05\x12\x04\\\ + \x02`\x03\x1a\xdb\x01\x20Returns\x20the\x20schema\x20of\x20a\x20Cloud\ + \x20Spanner\x20database\x20as\x20a\x20list\x20of\x20formatted\n\x20DDL\ + \x20statements.\x20This\x20method\x20does\x20not\x20show\x20pending\x20s\ + chema\x20updates,\x20those\x20may\n\x20be\x20queried\x20using\x20the\x20\ + [Operations][google.longrunning.Operations]\x20API.\n\n\x0c\n\x05\x06\0\ + \x02\x05\x01\x12\x03\\\x06\x14\n\x0c\n\x05\x06\0\x02\x05\x02\x12\x03\\\ + \x15*\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03\\5K\n\r\n\x05\x06\0\x02\x05\ + \x04\x12\x04]\x04_\x06\n\x11\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\"\x12\x04\ + ]\x04_\x06\n\xe7\x01\n\x04\x06\0\x02\x06\x12\x04g\x02l\x03\x1a\xd8\x01\ + \x20Sets\x20the\x20access\x20control\x20policy\x20on\x20a\x20database\ + \x20resource.\x20Replaces\x20any\n\x20existing\x20policy.\n\n\x20Authori\ + zation\x20requires\x20`spanner.databases.setIamPolicy`\x20permission\x20\ + on\n\x20[resource][google.iam.v1.SetIamPolicyRequest.resource].\n\n\x0c\ + \n\x05\x06\0\x02\x06\x01\x12\x03g\x06\x12\n\x0c\n\x05\x06\0\x02\x06\x02\ + \x12\x03g\x134\n\x0c\n\x05\x06\0\x02\x06\x03\x12\x03g?S\n\r\n\x05\x06\0\ + \x02\x06\x04\x12\x04h\x04k\x06\n\x11\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\ + \x12\x04h\x04k\x06\n\x97\x02\n\x04\x06\0\x02\x07\x12\x04s\x02x\x03\x1a\ + \x88\x02\x20Gets\x20the\x20access\x20control\x20policy\x20for\x20a\x20da\ + tabase\x20resource.\x20Returns\x20an\x20empty\n\x20policy\x20if\x20a\x20\ + database\x20exists\x20but\x20does\x20not\x20have\x20a\x20policy\x20set.\ + \n\n\x20Authorization\x20requires\x20`spanner.databases.getIamPolicy`\ + \x20permission\x20on\n\x20[resource][google.iam.v1.GetIamPolicyRequest.r\ + esource].\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03s\x06\x12\n\x0c\n\x05\ + \x06\0\x02\x07\x02\x12\x03s\x134\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03s?\ + S\n\r\n\x05\x06\0\x02\x07\x04\x12\x04t\x04w\x06\n\x11\n\t\x06\0\x02\x07\ + \x04\xb0\xca\xbc\"\x12\x04t\x04w\x06\n\xce\x02\n\x04\x06\0\x02\x08\x12\ + \x06\x80\x01\x02\x85\x01\x03\x1a\xbd\x02\x20Returns\x20permissions\x20th\ + at\x20the\x20caller\x20has\x20on\x20the\x20specified\x20database\x20reso\ + urce.\n\n\x20Attempting\x20this\x20RPC\x20on\x20a\x20non-existent\x20Clo\ + ud\x20Spanner\x20database\x20will\x20result\x20in\n\x20a\x20NOT_FOUND\ + \x20error\x20if\x20the\x20user\x20has\x20`spanner.databases.list`\x20per\ + mission\x20on\n\x20the\x20containing\x20Cloud\x20Spanner\x20instance.\ + \x20Otherwise\x20returns\x20an\x20empty\x20set\x20of\n\x20permissions.\n\ + \n\r\n\x05\x06\0\x02\x08\x01\x12\x04\x80\x01\x06\x18\n\r\n\x05\x06\0\x02\ + \x08\x02\x12\x04\x80\x01\x19@\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\x80\ + \x01Ks\n\x0f\n\x05\x06\0\x02\x08\x04\x12\x06\x81\x01\x04\x84\x01\x06\n\ + \x13\n\t\x06\0\x02\x08\x04\xb0\xca\xbc\"\x12\x06\x81\x01\x04\x84\x01\x06\ + \n)\n\x02\x04\0\x12\x06\x89\x01\0\xa0\x01\x01\x1a\x1b\x20A\x20Cloud\x20S\ + panner\x20database.\n\n\x0b\n\x03\x04\0\x01\x12\x04\x89\x01\x08\x10\n>\n\ + \x04\x04\0\x04\0\x12\x06\x8b\x01\x02\x95\x01\x03\x1a.\x20Indicates\x20th\ + e\x20current\x20state\x20of\x20the\x20database.\n\n\r\n\x05\x04\0\x04\0\ + \x01\x12\x04\x8b\x01\x07\x0c\n\x20\n\x06\x04\0\x04\0\x02\0\x12\x04\x8d\ + \x01\x04\x1a\x1a\x10\x20Not\x20specified.\n\n\x0f\n\x07\x04\0\x04\0\x02\ + \0\x01\x12\x04\x8d\x01\x04\x15\n\x0f\n\x07\x04\0\x04\0\x02\0\x02\x12\x04\ + \x8d\x01\x18\x19\n\x85\x01\n\x06\x04\0\x04\0\x02\x01\x12\x04\x91\x01\x04\ + \x11\x1au\x20The\x20database\x20is\x20still\x20being\x20created.\x20Oper\ + ations\x20on\x20the\x20database\x20may\x20fail\n\x20with\x20`FAILED_PREC\ + ONDITION`\x20in\x20this\x20state.\n\n\x0f\n\x07\x04\0\x04\0\x02\x01\x01\ + \x12\x04\x91\x01\x04\x0c\n\x0f\n\x07\x04\0\x04\0\x02\x01\x02\x12\x04\x91\ + \x01\x0f\x10\nB\n\x06\x04\0\x04\0\x02\x02\x12\x04\x94\x01\x04\x0e\x1a2\ + \x20The\x20database\x20is\x20fully\x20created\x20and\x20ready\x20for\x20\ + use.\n\n\x0f\n\x07\x04\0\x04\0\x02\x02\x01\x12\x04\x94\x01\x04\t\n\x0f\n\ + \x07\x04\0\x04\0\x02\x02\x02\x12\x04\x94\x01\x0c\r\n\x9d\x02\n\x04\x04\0\ + \x02\0\x12\x04\x9c\x01\x02\x12\x1a\x8e\x02\x20Required.\x20The\x20name\ + \x20of\x20the\x20database.\x20Values\x20are\x20of\x20the\x20form\n\x20`p\ + rojects//instances//databases/`,\n\x20where\ + \x20``\x20is\x20as\x20specified\x20in\x20the\x20`CREATE\x20DAT\ + ABASE`\n\x20statement.\x20This\x20name\x20can\x20be\x20passed\x20to\x20o\ + ther\x20API\x20methods\x20to\n\x20identify\x20the\x20database.\n\n\x0f\n\ + \x05\x04\0\x02\0\x04\x12\x06\x9c\x01\x02\x95\x01\x03\n\r\n\x05\x04\0\x02\ + \0\x05\x12\x04\x9c\x01\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\x9c\x01\ + \t\r\n\r\n\x05\x04\0\x02\0\x03\x12\x04\x9c\x01\x10\x11\n8\n\x04\x04\0\ + \x02\x01\x12\x04\x9f\x01\x02\x12\x1a*\x20Output\x20only.\x20The\x20curre\ + nt\x20database\x20state.\n\n\x0f\n\x05\x04\0\x02\x01\x04\x12\x06\x9f\x01\ + \x02\x9c\x01\x12\n\r\n\x05\x04\0\x02\x01\x06\x12\x04\x9f\x01\x02\x07\n\r\ + \n\x05\x04\0\x02\x01\x01\x12\x04\x9f\x01\x08\r\n\r\n\x05\x04\0\x02\x01\ + \x03\x12\x04\x9f\x01\x10\x11\nn\n\x02\x04\x01\x12\x06\xa3\x01\0\xb0\x01\ + \x01\x1a`\x20The\x20request\x20for\x20[ListDatabases][google.spanner.adm\ + in.database.v1.DatabaseAdmin.ListDatabases].\n\n\x0b\n\x03\x04\x01\x01\ + \x12\x04\xa3\x01\x08\x1c\n\x8b\x01\n\x04\x04\x01\x02\0\x12\x04\xa6\x01\ + \x02\x14\x1a}\x20Required.\x20The\x20instance\x20whose\x20databases\x20s\ + hould\x20be\x20listed.\n\x20Values\x20are\x20of\x20the\x20form\x20`proje\ + cts//instances/`.\n\n\x0f\n\x05\x04\x01\x02\0\x04\x12\ + \x06\xa6\x01\x02\xa3\x01\x1e\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\xa6\x01\ + \x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xa6\x01\t\x0f\n\r\n\x05\x04\ + \x01\x02\0\x03\x12\x04\xa6\x01\x12\x13\n\x86\x01\n\x04\x04\x01\x02\x01\ + \x12\x04\xaa\x01\x02\x16\x1ax\x20Number\x20of\x20databases\x20to\x20be\ + \x20returned\x20in\x20the\x20response.\x20If\x200\x20or\x20less,\n\x20de\ + faults\x20to\x20the\x20server's\x20maximum\x20allowed\x20page\x20size.\n\ + \n\x0f\n\x05\x04\x01\x02\x01\x04\x12\x06\xaa\x01\x02\xa6\x01\x14\n\r\n\ + \x05\x04\x01\x02\x01\x05\x12\x04\xaa\x01\x02\x07\n\r\n\x05\x04\x01\x02\ + \x01\x01\x12\x04\xaa\x01\x08\x11\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\ + \xaa\x01\x14\x15\n\xf9\x01\n\x04\x04\x01\x02\x02\x12\x04\xaf\x01\x02\x18\ + \x1a\xea\x01\x20If\x20non-empty,\x20`page_token`\x20should\x20contain\ + \x20a\n\x20[next_page_token][google.spanner.admin.database.v1.ListDataba\ + sesResponse.next_page_token]\x20from\x20a\n\x20previous\x20[ListDatabase\ + sResponse][google.spanner.admin.database.v1.ListDatabasesResponse].\n\n\ + \x0f\n\x05\x04\x01\x02\x02\x04\x12\x06\xaf\x01\x02\xaa\x01\x16\n\r\n\x05\ + \x04\x01\x02\x02\x05\x12\x04\xaf\x01\x02\x08\n\r\n\x05\x04\x01\x02\x02\ + \x01\x12\x04\xaf\x01\t\x13\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\xaf\x01\ + \x16\x17\no\n\x02\x04\x02\x12\x06\xb3\x01\0\xbb\x01\x01\x1aa\x20The\x20r\ + esponse\x20for\x20[ListDatabases][google.spanner.admin.database.v1.Datab\ + aseAdmin.ListDatabases].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xb3\x01\x08\ + \x1d\n3\n\x04\x04\x02\x02\0\x12\x04\xb5\x01\x02\"\x1a%\x20Databases\x20t\ + hat\x20matched\x20the\x20request.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04\ + \xb5\x01\x02\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xb5\x01\x0b\x13\n\r\n\ + \x05\x04\x02\x02\0\x01\x12\x04\xb5\x01\x14\x1d\n\r\n\x05\x04\x02\x02\0\ + \x03\x12\x04\xb5\x01\x20!\n\xbc\x01\n\x04\x04\x02\x02\x01\x12\x04\xba\ + \x01\x02\x1d\x1a\xad\x01\x20`next_page_token`\x20can\x20be\x20sent\x20in\ + \x20a\x20subsequent\n\x20[ListDatabases][google.spanner.admin.database.v\ + 1.DatabaseAdmin.ListDatabases]\x20call\x20to\x20fetch\x20more\n\x20of\ + \x20the\x20matching\x20databases.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\ + \x06\xba\x01\x02\xb5\x01\"\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xba\x01\ + \x02\x08\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xba\x01\t\x18\n\r\n\x05\ + \x04\x02\x02\x01\x03\x12\x04\xba\x01\x1b\x1c\np\n\x02\x04\x03\x12\x06\ + \xbe\x01\0\xcf\x01\x01\x1ab\x20The\x20request\x20for\x20[CreateDatabase]\ + [google.spanner.admin.database.v1.DatabaseAdmin.CreateDatabase].\n\n\x0b\ + \n\x03\x04\x03\x01\x12\x04\xbe\x01\x08\x1d\n\x98\x01\n\x04\x04\x03\x02\0\ + \x12\x04\xc1\x01\x02\x14\x1a\x89\x01\x20Required.\x20The\x20name\x20of\ + \x20the\x20instance\x20that\x20will\x20serve\x20the\x20new\x20database.\ + \n\x20Values\x20are\x20of\x20the\x20form\x20`projects//instance\ + s/`.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xc1\x01\x02\xbe\ + \x01\x1f\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\xc1\x01\x02\x08\n\r\n\x05\ + \x04\x03\x02\0\x01\x12\x04\xc1\x01\t\x0f\n\r\n\x05\x04\x03\x02\0\x03\x12\ + \x04\xc1\x01\x12\x13\n\xe6\x02\n\x04\x04\x03\x02\x01\x12\x04\xc8\x01\x02\ + \x1e\x1a\xd7\x02\x20Required.\x20A\x20`CREATE\x20DATABASE`\x20statement,\ + \x20which\x20specifies\x20the\x20ID\x20of\x20the\n\x20new\x20database.\ + \x20\x20The\x20database\x20ID\x20must\x20conform\x20to\x20the\x20regular\ + \x20expression\n\x20`[a-z][a-z0-9_\\-]*[a-z0-9]`\x20and\x20be\x20between\ + \x202\x20and\x2030\x20characters\x20in\x20length.\n\x20If\x20the\x20data\ + base\x20ID\x20is\x20a\x20reserved\x20word\x20or\x20if\x20it\x20contains\ + \x20a\x20hyphen,\x20the\n\x20database\x20ID\x20must\x20be\x20enclosed\ + \x20in\x20backticks\x20(``\x20`\x20``).\n\n\x0f\n\x05\x04\x03\x02\x01\ + \x04\x12\x06\xc8\x01\x02\xc1\x01\x14\n\r\n\x05\x04\x03\x02\x01\x05\x12\ + \x04\xc8\x01\x02\x08\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\xc8\x01\t\x19\ + \n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xc8\x01\x1c\x1d\n\x97\x02\n\x04\ + \x04\x03\x02\x02\x12\x04\xce\x01\x02'\x1a\x88\x02\x20An\x20optional\x20l\ + ist\x20of\x20DDL\x20statements\x20to\x20run\x20inside\x20the\x20newly\ + \x20created\n\x20database.\x20Statements\x20can\x20create\x20tables,\x20\ + indexes,\x20etc.\x20These\n\x20statements\x20execute\x20atomically\x20wi\ + th\x20the\x20creation\x20of\x20the\x20database:\n\x20if\x20there\x20is\ + \x20an\x20error\x20in\x20any\x20statement,\x20the\x20database\x20is\x20n\ + ot\x20created.\n\n\r\n\x05\x04\x03\x02\x02\x04\x12\x04\xce\x01\x02\n\n\r\ + \n\x05\x04\x03\x02\x02\x05\x12\x04\xce\x01\x0b\x11\n\r\n\x05\x04\x03\x02\ + \x02\x01\x12\x04\xce\x01\x12\"\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xce\ + \x01%&\n\x8d\x01\n\x02\x04\x04\x12\x06\xd3\x01\0\xd6\x01\x01\x1a\x7f\x20\ + Metadata\x20type\x20for\x20the\x20operation\x20returned\x20by\n\x20[Crea\ + teDatabase][google.spanner.admin.database.v1.DatabaseAdmin.CreateDatabas\ + e].\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xd3\x01\x08\x1e\n+\n\x04\x04\x04\ + \x02\0\x12\x04\xd5\x01\x02\x16\x1a\x1d\x20The\x20database\x20being\x20cr\ + eated.\n\n\x0f\n\x05\x04\x04\x02\0\x04\x12\x06\xd5\x01\x02\xd3\x01\x20\n\ + \r\n\x05\x04\x04\x02\0\x05\x12\x04\xd5\x01\x02\x08\n\r\n\x05\x04\x04\x02\ + \0\x01\x12\x04\xd5\x01\t\x11\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xd5\x01\ + \x14\x15\nj\n\x02\x04\x05\x12\x06\xd9\x01\0\xdd\x01\x01\x1a\\\x20The\x20\ + request\x20for\x20[GetDatabase][google.spanner.admin.database.v1.Databas\ + eAdmin.GetDatabase].\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xd9\x01\x08\x1a\n\ + \x96\x01\n\x04\x04\x05\x02\0\x12\x04\xdc\x01\x02\x12\x1a\x87\x01\x20Requ\ + ired.\x20The\x20name\x20of\x20the\x20requested\x20database.\x20Values\ + \x20are\x20of\x20the\x20form\n\x20`projects//instances//databases/`.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\xdc\ + \x01\x02\xd9\x01\x1c\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xdc\x01\x02\x08\ + \n\r\n\x05\x04\x05\x02\0\x01\x12\x04\xdc\x01\t\r\n\r\n\x05\x04\x05\x02\0\ + \x03\x12\x04\xdc\x01\x10\x11\n\x99\x07\n\x02\x04\x06\x12\x06\xef\x01\0\ + \x8a\x02\x01\x1a\x8a\x07\x20Enqueues\x20the\x20given\x20DDL\x20statement\ + s\x20to\x20be\x20applied,\x20in\x20order\x20but\x20not\n\x20necessarily\ + \x20all\x20at\x20once,\x20to\x20the\x20database\x20schema\x20at\x20some\ + \x20point\x20(or\n\x20points)\x20in\x20the\x20future.\x20The\x20server\ + \x20checks\x20that\x20the\x20statements\n\x20are\x20executable\x20(synta\ + ctically\x20valid,\x20name\x20tables\x20that\x20exist,\x20etc.)\n\x20bef\ + ore\x20enqueueing\x20them,\x20but\x20they\x20may\x20still\x20fail\x20upo\ + n\n\x20later\x20execution\x20(e.g.,\x20if\x20a\x20statement\x20from\x20a\ + nother\x20batch\x20of\n\x20statements\x20is\x20applied\x20first\x20and\ + \x20it\x20conflicts\x20in\x20some\x20way,\x20or\x20if\n\x20there\x20is\ + \x20some\x20data-related\x20problem\x20like\x20a\x20`NULL`\x20value\x20i\ + n\x20a\x20column\x20to\n\x20which\x20`NOT\x20NULL`\x20would\x20be\x20add\ + ed).\x20If\x20a\x20statement\x20fails,\x20all\n\x20subsequent\x20stateme\ + nts\x20in\x20the\x20batch\x20are\x20automatically\x20cancelled.\n\n\x20E\ + ach\x20batch\x20of\x20statements\x20is\x20assigned\x20a\x20name\x20which\ + \x20can\x20be\x20used\x20with\n\x20the\x20[Operations][google.longrunnin\ + g.Operations]\x20API\x20to\x20monitor\n\x20progress.\x20See\x20the\n\x20\ + [operation_id][google.spanner.admin.database.v1.UpdateDatabaseDdlRequest\ + .operation_id]\x20field\x20for\x20more\n\x20details.\n\n\x0b\n\x03\x04\ + \x06\x01\x12\x04\xef\x01\x08\x20\n1\n\x04\x04\x06\x02\0\x12\x04\xf1\x01\ + \x02\x16\x1a#\x20Required.\x20The\x20database\x20to\x20update.\n\n\x0f\n\ + \x05\x04\x06\x02\0\x04\x12\x06\xf1\x01\x02\xef\x01\"\n\r\n\x05\x04\x06\ + \x02\0\x05\x12\x04\xf1\x01\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\ + \xf1\x01\t\x11\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xf1\x01\x14\x15\n=\n\ + \x04\x04\x06\x02\x01\x12\x04\xf4\x01\x02!\x1a/\x20DDL\x20statements\x20t\ + o\x20be\x20applied\x20to\x20the\x20database.\n\n\r\n\x05\x04\x06\x02\x01\ + \x04\x12\x04\xf4\x01\x02\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xf4\x01\ + \x0b\x11\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xf4\x01\x12\x1c\n\r\n\x05\ + \x04\x06\x02\x01\x03\x12\x04\xf4\x01\x1f\x20\n\xe4\x08\n\x04\x04\x06\x02\ + \x02\x12\x04\x89\x02\x02\x1a\x1a\xd5\x08\x20If\x20empty,\x20the\x20new\ + \x20update\x20request\x20is\x20assigned\x20an\n\x20automatically-generat\ + ed\x20operation\x20ID.\x20Otherwise,\x20`operation_id`\n\x20is\x20used\ + \x20to\x20construct\x20the\x20name\x20of\x20the\x20resulting\n\x20[Opera\ + tion][google.longrunning.Operation].\n\n\x20Specifying\x20an\x20explicit\ + \x20operation\x20ID\x20simplifies\x20determining\n\x20whether\x20the\x20\ + statements\x20were\x20executed\x20in\x20the\x20event\x20that\x20the\n\ + \x20[UpdateDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.U\ + pdateDatabaseDdl]\x20call\x20is\x20replayed,\n\x20or\x20the\x20return\ + \x20value\x20is\x20otherwise\x20lost:\x20the\x20[database][google.spanne\ + r.admin.database.v1.UpdateDatabaseDdlRequest.database]\x20and\n\x20`oper\ + ation_id`\x20fields\x20can\x20be\x20combined\x20to\x20form\x20the\n\x20[\ + name][google.longrunning.Operation.name]\x20of\x20the\x20resulting\n\x20\ + [longrunning.Operation][google.longrunning.Operation]:\x20`/op\ + erations/`.\n\n\x20`operation_id`\x20should\x20be\x20uniqu\ + e\x20within\x20the\x20database,\x20and\x20must\x20be\n\x20a\x20valid\x20\ + identifier:\x20`[a-z][a-z0-9_]*`.\x20Note\x20that\n\x20automatically-gen\ + erated\x20operation\x20IDs\x20always\x20begin\x20with\x20an\n\x20undersc\ + ore.\x20If\x20the\x20named\x20operation\x20already\x20exists,\n\x20[Upda\ + teDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.UpdateData\ + baseDdl]\x20returns\n\x20`ALREADY_EXISTS`.\n\n\x0f\n\x05\x04\x06\x02\x02\ + \x04\x12\x06\x89\x02\x02\xf4\x01!\n\r\n\x05\x04\x06\x02\x02\x05\x12\x04\ + \x89\x02\x02\x08\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\x89\x02\t\x15\n\r\ + \n\x05\x04\x06\x02\x02\x03\x12\x04\x89\x02\x18\x19\n\x94\x01\n\x02\x04\ + \x07\x12\x06\x8e\x02\0\x9a\x02\x01\x1a\x85\x01\x20Metadata\x20type\x20fo\ + r\x20the\x20operation\x20returned\x20by\n\x20[UpdateDatabaseDdl][google.\ + spanner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl].\n\n\x0b\n\ + \x03\x04\x07\x01\x12\x04\x8e\x02\x08!\n,\n\x04\x04\x07\x02\0\x12\x04\x90\ + \x02\x02\x16\x1a\x1e\x20The\x20database\x20being\x20modified.\n\n\x0f\n\ + \x05\x04\x07\x02\0\x04\x12\x06\x90\x02\x02\x8e\x02#\n\r\n\x05\x04\x07\ + \x02\0\x05\x12\x04\x90\x02\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\ + \x90\x02\t\x11\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\x90\x02\x14\x15\n\x8a\ + \x01\n\x04\x04\x07\x02\x01\x12\x04\x94\x02\x02!\x1a|\x20For\x20an\x20upd\ + ate\x20this\x20list\x20contains\x20all\x20the\x20statements.\x20For\x20a\ + n\n\x20individual\x20statement,\x20this\x20list\x20contains\x20only\x20t\ + hat\x20statement.\n\n\r\n\x05\x04\x07\x02\x01\x04\x12\x04\x94\x02\x02\n\ + \n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\x94\x02\x0b\x11\n\r\n\x05\x04\x07\ + \x02\x01\x01\x12\x04\x94\x02\x12\x1c\n\r\n\x05\x04\x07\x02\x01\x03\x12\ + \x04\x94\x02\x1f\x20\n\xb6\x01\n\x04\x04\x07\x02\x02\x12\x04\x99\x02\x02\ + ;\x1a\xa7\x01\x20Reports\x20the\x20commit\x20timestamps\x20of\x20all\x20\ + statements\x20that\x20have\n\x20succeeded\x20so\x20far,\x20where\x20`com\ + mit_timestamps[i]`\x20is\x20the\x20commit\n\x20timestamp\x20for\x20the\ + \x20statement\x20`statements[i]`.\n\n\r\n\x05\x04\x07\x02\x02\x04\x12\ + \x04\x99\x02\x02\n\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\x99\x02\x0b$\n\ + \r\n\x05\x04\x07\x02\x02\x01\x12\x04\x99\x02%6\n\r\n\x05\x04\x07\x02\x02\ + \x03\x12\x04\x99\x029:\nl\n\x02\x04\x08\x12\x06\x9d\x02\0\xa0\x02\x01\ + \x1a^\x20The\x20request\x20for\x20[DropDatabase][google.spanner.admin.da\ + tabase.v1.DatabaseAdmin.DropDatabase].\n\n\x0b\n\x03\x04\x08\x01\x12\x04\ + \x9d\x02\x08\x1b\n5\n\x04\x04\x08\x02\0\x12\x04\x9f\x02\x02\x16\x1a'\x20\ + Required.\x20The\x20database\x20to\x20be\x20dropped.\n\n\x0f\n\x05\x04\ + \x08\x02\0\x04\x12\x06\x9f\x02\x02\x9d\x02\x1d\n\r\n\x05\x04\x08\x02\0\ + \x05\x12\x04\x9f\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\x9f\x02\ + \t\x11\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x9f\x02\x14\x15\np\n\x02\x04\ + \t\x12\x06\xa3\x02\0\xa6\x02\x01\x1ab\x20The\x20request\x20for\x20[GetDa\ + tabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.GetDatabaseDdl\ + ].\n\n\x0b\n\x03\x04\t\x01\x12\x04\xa3\x02\x08\x1d\nC\n\x04\x04\t\x02\0\ + \x12\x04\xa5\x02\x02\x16\x1a5\x20Required.\x20The\x20database\x20whose\ + \x20schema\x20we\x20wish\x20to\x20get.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\ + \x06\xa5\x02\x02\xa3\x02\x1f\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xa5\x02\ + \x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xa5\x02\t\x11\n\r\n\x05\x04\t\ + \x02\0\x03\x12\x04\xa5\x02\x14\x15\nq\n\x02\x04\n\x12\x06\xa9\x02\0\xad\ + \x02\x01\x1ac\x20The\x20response\x20for\x20[GetDatabaseDdl][google.spann\ + er.admin.database.v1.DatabaseAdmin.GetDatabaseDdl].\n\n\x0b\n\x03\x04\n\ + \x01\x12\x04\xa9\x02\x08\x1e\nq\n\x04\x04\n\x02\0\x12\x04\xac\x02\x02!\ + \x1ac\x20A\x20list\x20of\x20formatted\x20DDL\x20statements\x20defining\ + \x20the\x20schema\x20of\x20the\x20database\n\x20specified\x20in\x20the\ + \x20request.\n\n\r\n\x05\x04\n\x02\0\x04\x12\x04\xac\x02\x02\n\n\r\n\x05\ + \x04\n\x02\0\x05\x12\x04\xac\x02\x0b\x11\n\r\n\x05\x04\n\x02\0\x01\x12\ + \x04\xac\x02\x12\x1c\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xac\x02\x1f\x20b\ + \x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin_grpc.rs new file mode 100644 index 00000000..6b8d47d8 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/database/v1/spanner_database_admin_grpc.rs @@ -0,0 +1,295 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_DATABASE_ADMIN_LIST_DATABASES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/ListDatabases", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_CREATE_DATABASE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/CreateDatabase", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_GET_DATABASE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabase", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_UPDATE_DATABASE_DDL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/UpdateDatabaseDdl", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_DROP_DATABASE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/DropDatabase", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_GET_DATABASE_DDL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabaseDdl", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_SET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/SetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_GET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/GetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_DATABASE_ADMIN_TEST_IAM_PERMISSIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.database.v1.DatabaseAdmin/TestIamPermissions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct DatabaseAdminClient { + client: ::grpcio::Client, +} + +impl DatabaseAdminClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + DatabaseAdminClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn list_databases_opt(&self, req: &super::spanner_database_admin::ListDatabasesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_LIST_DATABASES, req, opt) + } + + pub fn list_databases(&self, req: &super::spanner_database_admin::ListDatabasesRequest) -> ::grpcio::Result { + self.list_databases_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_databases_async_opt(&self, req: &super::spanner_database_admin::ListDatabasesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_LIST_DATABASES, req, opt) + } + + pub fn list_databases_async(&self, req: &super::spanner_database_admin::ListDatabasesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_databases_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_database_opt(&self, req: &super::spanner_database_admin::CreateDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_CREATE_DATABASE, req, opt) + } + + pub fn create_database(&self, req: &super::spanner_database_admin::CreateDatabaseRequest) -> ::grpcio::Result { + self.create_database_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_database_async_opt(&self, req: &super::spanner_database_admin::CreateDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_CREATE_DATABASE, req, opt) + } + + pub fn create_database_async(&self, req: &super::spanner_database_admin::CreateDatabaseRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_database_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_database_opt(&self, req: &super::spanner_database_admin::GetDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_GET_DATABASE, req, opt) + } + + pub fn get_database(&self, req: &super::spanner_database_admin::GetDatabaseRequest) -> ::grpcio::Result { + self.get_database_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_database_async_opt(&self, req: &super::spanner_database_admin::GetDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_GET_DATABASE, req, opt) + } + + pub fn get_database_async(&self, req: &super::spanner_database_admin::GetDatabaseRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_database_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_database_ddl_opt(&self, req: &super::spanner_database_admin::UpdateDatabaseDdlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_UPDATE_DATABASE_DDL, req, opt) + } + + pub fn update_database_ddl(&self, req: &super::spanner_database_admin::UpdateDatabaseDdlRequest) -> ::grpcio::Result { + self.update_database_ddl_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_database_ddl_async_opt(&self, req: &super::spanner_database_admin::UpdateDatabaseDdlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_UPDATE_DATABASE_DDL, req, opt) + } + + pub fn update_database_ddl_async(&self, req: &super::spanner_database_admin::UpdateDatabaseDdlRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_database_ddl_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn drop_database_opt(&self, req: &super::spanner_database_admin::DropDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_DROP_DATABASE, req, opt) + } + + pub fn drop_database(&self, req: &super::spanner_database_admin::DropDatabaseRequest) -> ::grpcio::Result { + self.drop_database_opt(req, ::grpcio::CallOption::default()) + } + + pub fn drop_database_async_opt(&self, req: &super::spanner_database_admin::DropDatabaseRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_DROP_DATABASE, req, opt) + } + + pub fn drop_database_async(&self, req: &super::spanner_database_admin::DropDatabaseRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.drop_database_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_database_ddl_opt(&self, req: &super::spanner_database_admin::GetDatabaseDdlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_GET_DATABASE_DDL, req, opt) + } + + pub fn get_database_ddl(&self, req: &super::spanner_database_admin::GetDatabaseDdlRequest) -> ::grpcio::Result { + self.get_database_ddl_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_database_ddl_async_opt(&self, req: &super::spanner_database_admin::GetDatabaseDdlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_GET_DATABASE_DDL, req, opt) + } + + pub fn get_database_ddl_async(&self, req: &super::spanner_database_admin::GetDatabaseDdlRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_database_ddl_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result { + self.set_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_async_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy_async(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.set_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result { + self.get_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_async_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy_async(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_DATABASE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result { + self.test_iam_permissions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_async_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_DATABASE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions_async(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.test_iam_permissions_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait DatabaseAdmin { + fn list_databases(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::ListDatabasesRequest, sink: ::grpcio::UnarySink); + fn create_database(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::CreateDatabaseRequest, sink: ::grpcio::UnarySink); + fn get_database(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::GetDatabaseRequest, sink: ::grpcio::UnarySink); + fn update_database_ddl(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::UpdateDatabaseDdlRequest, sink: ::grpcio::UnarySink); + fn drop_database(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::DropDatabaseRequest, sink: ::grpcio::UnarySink); + fn get_database_ddl(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_database_admin::GetDatabaseDdlRequest, sink: ::grpcio::UnarySink); + fn set_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::SetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn get_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::GetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn test_iam_permissions(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::TestIamPermissionsRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_database_admin(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_LIST_DATABASES, move |ctx, req, resp| { + instance.list_databases(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_CREATE_DATABASE, move |ctx, req, resp| { + instance.create_database(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_GET_DATABASE, move |ctx, req, resp| { + instance.get_database(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_UPDATE_DATABASE_DDL, move |ctx, req, resp| { + instance.update_database_ddl(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_DROP_DATABASE, move |ctx, req, resp| { + instance.drop_database(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_GET_DATABASE_DDL, move |ctx, req, resp| { + instance.get_database_ddl(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_SET_IAM_POLICY, move |ctx, req, resp| { + instance.set_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_GET_IAM_POLICY, move |ctx, req, resp| { + instance.get_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_DATABASE_ADMIN_TEST_IAM_PERMISSIONS, move |ctx, req, resp| { + instance.test_iam_permissions(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/mod.rs new file mode 100644 index 00000000..a3a6d96c --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/mod.rs new file mode 100644 index 00000000..35feced3 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/mod.rs @@ -0,0 +1,8 @@ +pub mod spanner_instance_admin; +pub mod spanner_instance_admin_grpc; + +pub(crate) use crate::{ + empty, + iam::v1::{iam_policy, policy}, + longrunning::operations, +}; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin.rs new file mode 100644 index 00000000..674f7e19 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin.rs @@ -0,0 +1,3977 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/admin/instance/v1/spanner_instance_admin.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct InstanceConfig { + // message fields + pub name: ::std::string::String, + pub display_name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a InstanceConfig { + fn default() -> &'a InstanceConfig { + ::default_instance() + } +} + +impl InstanceConfig { + pub fn new() -> InstanceConfig { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string display_name = 2; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for InstanceConfig { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.display_name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.display_name.is_empty() { + os.write_string(2, &self.display_name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> InstanceConfig { + InstanceConfig::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &InstanceConfig| { &m.name }, + |m: &mut InstanceConfig| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &InstanceConfig| { &m.display_name }, + |m: &mut InstanceConfig| { &mut m.display_name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "InstanceConfig", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static InstanceConfig { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const InstanceConfig, + }; + unsafe { + instance.get(InstanceConfig::new) + } + } +} + +impl ::protobuf::Clear for InstanceConfig { + fn clear(&mut self) { + self.name.clear(); + self.display_name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for InstanceConfig { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for InstanceConfig { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Instance { + // message fields + pub name: ::std::string::String, + pub config: ::std::string::String, + pub display_name: ::std::string::String, + pub node_count: i32, + pub state: Instance_State, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Instance { + fn default() -> &'a Instance { + ::default_instance() + } +} + +impl Instance { + pub fn new() -> Instance { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string config = 2; + + + pub fn get_config(&self) -> &str { + &self.config + } + pub fn clear_config(&mut self) { + self.config.clear(); + } + + // Param is passed by value, moved + pub fn set_config(&mut self, v: ::std::string::String) { + self.config = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_config(&mut self) -> &mut ::std::string::String { + &mut self.config + } + + // Take field + pub fn take_config(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.config, ::std::string::String::new()) + } + + // string display_name = 3; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } + + // int32 node_count = 5; + + + pub fn get_node_count(&self) -> i32 { + self.node_count + } + pub fn clear_node_count(&mut self) { + self.node_count = 0; + } + + // Param is passed by value, moved + pub fn set_node_count(&mut self, v: i32) { + self.node_count = v; + } + + // .google.spanner.admin.instance.v1.Instance.State state = 6; + + + pub fn get_state(&self) -> Instance_State { + self.state + } + pub fn clear_state(&mut self) { + self.state = Instance_State::STATE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_state(&mut self, v: Instance_State) { + self.state = v; + } + + // repeated .google.spanner.admin.instance.v1.Instance.LabelsEntry labels = 7; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for Instance { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.config)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.node_count = tmp; + }, + 6 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 6, &mut self.unknown_fields)? + }, + 7 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.config.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.config); + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.display_name); + } + if self.node_count != 0 { + my_size += ::protobuf::rt::value_size(5, self.node_count, ::protobuf::wire_format::WireTypeVarint); + } + if self.state != Instance_State::STATE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(6, self.state); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(7, &self.labels); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.config.is_empty() { + os.write_string(2, &self.config)?; + } + if !self.display_name.is_empty() { + os.write_string(3, &self.display_name)?; + } + if self.node_count != 0 { + os.write_int32(5, self.node_count)?; + } + if self.state != Instance_State::STATE_UNSPECIFIED { + os.write_enum(6, self.state.value())?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(7, &self.labels, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Instance { + Instance::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Instance| { &m.name }, + |m: &mut Instance| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "config", + |m: &Instance| { &m.config }, + |m: &mut Instance| { &mut m.config }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &Instance| { &m.display_name }, + |m: &mut Instance| { &mut m.display_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "node_count", + |m: &Instance| { &m.node_count }, + |m: &mut Instance| { &mut m.node_count }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "state", + |m: &Instance| { &m.state }, + |m: &mut Instance| { &mut m.state }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Instance| { &m.labels }, + |m: &mut Instance| { &mut m.labels }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Instance", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Instance { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Instance, + }; + unsafe { + instance.get(Instance::new) + } + } +} + +impl ::protobuf::Clear for Instance { + fn clear(&mut self) { + self.name.clear(); + self.config.clear(); + self.display_name.clear(); + self.node_count = 0; + self.state = Instance_State::STATE_UNSPECIFIED; + self.labels.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Instance { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Instance { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum Instance_State { + STATE_UNSPECIFIED = 0, + CREATING = 1, + READY = 2, +} + +impl ::protobuf::ProtobufEnum for Instance_State { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Instance_State::STATE_UNSPECIFIED), + 1 => ::std::option::Option::Some(Instance_State::CREATING), + 2 => ::std::option::Option::Some(Instance_State::READY), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Instance_State] = &[ + Instance_State::STATE_UNSPECIFIED, + Instance_State::CREATING, + Instance_State::READY, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("Instance_State", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Instance_State { +} + +impl ::std::default::Default for Instance_State { + fn default() -> Self { + Instance_State::STATE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for Instance_State { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstanceConfigsRequest { + // message fields + pub parent: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstanceConfigsRequest { + fn default() -> &'a ListInstanceConfigsRequest { + ::default_instance() + } +} + +impl ListInstanceConfigsRequest { + pub fn new() -> ListInstanceConfigsRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstanceConfigsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstanceConfigsRequest { + ListInstanceConfigsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListInstanceConfigsRequest| { &m.parent }, + |m: &mut ListInstanceConfigsRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListInstanceConfigsRequest| { &m.page_size }, + |m: &mut ListInstanceConfigsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListInstanceConfigsRequest| { &m.page_token }, + |m: &mut ListInstanceConfigsRequest| { &mut m.page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstanceConfigsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstanceConfigsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstanceConfigsRequest, + }; + unsafe { + instance.get(ListInstanceConfigsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListInstanceConfigsRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_size = 0; + self.page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstanceConfigsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstanceConfigsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstanceConfigsResponse { + // message fields + pub instance_configs: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstanceConfigsResponse { + fn default() -> &'a ListInstanceConfigsResponse { + ::default_instance() + } +} + +impl ListInstanceConfigsResponse { + pub fn new() -> ListInstanceConfigsResponse { + ::std::default::Default::default() + } + + // repeated .google.spanner.admin.instance.v1.InstanceConfig instance_configs = 1; + + + pub fn get_instance_configs(&self) -> &[InstanceConfig] { + &self.instance_configs + } + pub fn clear_instance_configs(&mut self) { + self.instance_configs.clear(); + } + + // Param is passed by value, moved + pub fn set_instance_configs(&mut self, v: ::protobuf::RepeatedField) { + self.instance_configs = v; + } + + // Mutable pointer to the field. + pub fn mut_instance_configs(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.instance_configs + } + + // Take field + pub fn take_instance_configs(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.instance_configs, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstanceConfigsResponse { + fn is_initialized(&self) -> bool { + for v in &self.instance_configs { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.instance_configs)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.instance_configs { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.instance_configs { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstanceConfigsResponse { + ListInstanceConfigsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance_configs", + |m: &ListInstanceConfigsResponse| { &m.instance_configs }, + |m: &mut ListInstanceConfigsResponse| { &mut m.instance_configs }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListInstanceConfigsResponse| { &m.next_page_token }, + |m: &mut ListInstanceConfigsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstanceConfigsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstanceConfigsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstanceConfigsResponse, + }; + unsafe { + instance.get(ListInstanceConfigsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListInstanceConfigsResponse { + fn clear(&mut self) { + self.instance_configs.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstanceConfigsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstanceConfigsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetInstanceConfigRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetInstanceConfigRequest { + fn default() -> &'a GetInstanceConfigRequest { + ::default_instance() + } +} + +impl GetInstanceConfigRequest { + pub fn new() -> GetInstanceConfigRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetInstanceConfigRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetInstanceConfigRequest { + GetInstanceConfigRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetInstanceConfigRequest| { &m.name }, + |m: &mut GetInstanceConfigRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetInstanceConfigRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetInstanceConfigRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetInstanceConfigRequest, + }; + unsafe { + instance.get(GetInstanceConfigRequest::new) + } + } +} + +impl ::protobuf::Clear for GetInstanceConfigRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetInstanceConfigRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetInstanceConfigRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetInstanceRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetInstanceRequest { + fn default() -> &'a GetInstanceRequest { + ::default_instance() + } +} + +impl GetInstanceRequest { + pub fn new() -> GetInstanceRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetInstanceRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetInstanceRequest { + GetInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetInstanceRequest| { &m.name }, + |m: &mut GetInstanceRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetInstanceRequest, + }; + unsafe { + instance.get(GetInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for GetInstanceRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateInstanceRequest { + // message fields + pub parent: ::std::string::String, + pub instance_id: ::std::string::String, + pub instance: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateInstanceRequest { + fn default() -> &'a CreateInstanceRequest { + ::default_instance() + } +} + +impl CreateInstanceRequest { + pub fn new() -> CreateInstanceRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // string instance_id = 2; + + + pub fn get_instance_id(&self) -> &str { + &self.instance_id + } + pub fn clear_instance_id(&mut self) { + self.instance_id.clear(); + } + + // Param is passed by value, moved + pub fn set_instance_id(&mut self, v: ::std::string::String) { + self.instance_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance_id(&mut self) -> &mut ::std::string::String { + &mut self.instance_id + } + + // Take field + pub fn take_instance_id(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.instance_id, ::std::string::String::new()) + } + + // .google.spanner.admin.instance.v1.Instance instance = 3; + + + pub fn get_instance(&self) -> &Instance { + self.instance.as_ref().unwrap_or_else(|| Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> Instance { + self.instance.take().unwrap_or_else(|| Instance::new()) + } +} + +impl ::protobuf::Message for CreateInstanceRequest { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.instance_id)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if !self.instance_id.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.instance_id); + } + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if !self.instance_id.is_empty() { + os.write_string(2, &self.instance_id)?; + } + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateInstanceRequest { + CreateInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &CreateInstanceRequest| { &m.parent }, + |m: &mut CreateInstanceRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "instance_id", + |m: &CreateInstanceRequest| { &m.instance_id }, + |m: &mut CreateInstanceRequest| { &mut m.instance_id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &CreateInstanceRequest| { &m.instance }, + |m: &mut CreateInstanceRequest| { &mut m.instance }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateInstanceRequest, + }; + unsafe { + instance.get(CreateInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateInstanceRequest { + fn clear(&mut self) { + self.parent.clear(); + self.instance_id.clear(); + self.instance.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstancesRequest { + // message fields + pub parent: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + pub filter: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstancesRequest { + fn default() -> &'a ListInstancesRequest { + ::default_instance() + } +} + +impl ListInstancesRequest { + pub fn new() -> ListInstancesRequest { + ::std::default::Default::default() + } + + // string parent = 1; + + + pub fn get_parent(&self) -> &str { + &self.parent + } + pub fn clear_parent(&mut self) { + self.parent.clear(); + } + + // Param is passed by value, moved + pub fn set_parent(&mut self, v: ::std::string::String) { + self.parent = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent(&mut self) -> &mut ::std::string::String { + &mut self.parent + } + + // Take field + pub fn take_parent(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.parent, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } + + // string filter = 4; + + + pub fn get_filter(&self) -> &str { + &self.filter + } + pub fn clear_filter(&mut self) { + self.filter.clear(); + } + + // Param is passed by value, moved + pub fn set_filter(&mut self, v: ::std::string::String) { + self.filter = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_filter(&mut self) -> &mut ::std::string::String { + &mut self.filter + } + + // Take field + pub fn take_filter(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.filter, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstancesRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.parent)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filter)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.parent.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.parent); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + if !self.filter.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.filter); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.parent.is_empty() { + os.write_string(1, &self.parent)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + if !self.filter.is_empty() { + os.write_string(4, &self.filter)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstancesRequest { + ListInstancesRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parent", + |m: &ListInstancesRequest| { &m.parent }, + |m: &mut ListInstancesRequest| { &mut m.parent }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListInstancesRequest| { &m.page_size }, + |m: &mut ListInstancesRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListInstancesRequest| { &m.page_token }, + |m: &mut ListInstancesRequest| { &mut m.page_token }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "filter", + |m: &ListInstancesRequest| { &m.filter }, + |m: &mut ListInstancesRequest| { &mut m.filter }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstancesRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstancesRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstancesRequest, + }; + unsafe { + instance.get(ListInstancesRequest::new) + } + } +} + +impl ::protobuf::Clear for ListInstancesRequest { + fn clear(&mut self) { + self.parent.clear(); + self.page_size = 0; + self.page_token.clear(); + self.filter.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstancesRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstancesRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListInstancesResponse { + // message fields + pub instances: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListInstancesResponse { + fn default() -> &'a ListInstancesResponse { + ::default_instance() + } +} + +impl ListInstancesResponse { + pub fn new() -> ListInstancesResponse { + ::std::default::Default::default() + } + + // repeated .google.spanner.admin.instance.v1.Instance instances = 1; + + + pub fn get_instances(&self) -> &[Instance] { + &self.instances + } + pub fn clear_instances(&mut self) { + self.instances.clear(); + } + + // Param is passed by value, moved + pub fn set_instances(&mut self, v: ::protobuf::RepeatedField) { + self.instances = v; + } + + // Mutable pointer to the field. + pub fn mut_instances(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.instances + } + + // Take field + pub fn take_instances(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.instances, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListInstancesResponse { + fn is_initialized(&self) -> bool { + for v in &self.instances { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.instances)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.instances { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.instances { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListInstancesResponse { + ListInstancesResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instances", + |m: &ListInstancesResponse| { &m.instances }, + |m: &mut ListInstancesResponse| { &mut m.instances }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListInstancesResponse| { &m.next_page_token }, + |m: &mut ListInstancesResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListInstancesResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListInstancesResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListInstancesResponse, + }; + unsafe { + instance.get(ListInstancesResponse::new) + } + } +} + +impl ::protobuf::Clear for ListInstancesResponse { + fn clear(&mut self) { + self.instances.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListInstancesResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListInstancesResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateInstanceRequest { + // message fields + pub instance: ::protobuf::SingularPtrField, + pub field_mask: ::protobuf::SingularPtrField<::protobuf::well_known_types::FieldMask>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateInstanceRequest { + fn default() -> &'a UpdateInstanceRequest { + ::default_instance() + } +} + +impl UpdateInstanceRequest { + pub fn new() -> UpdateInstanceRequest { + ::std::default::Default::default() + } + + // .google.spanner.admin.instance.v1.Instance instance = 1; + + + pub fn get_instance(&self) -> &Instance { + self.instance.as_ref().unwrap_or_else(|| Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> Instance { + self.instance.take().unwrap_or_else(|| Instance::new()) + } + + // .google.protobuf.FieldMask field_mask = 2; + + + pub fn get_field_mask(&self) -> &::protobuf::well_known_types::FieldMask { + self.field_mask.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::default_instance()) + } + pub fn clear_field_mask(&mut self) { + self.field_mask.clear(); + } + + pub fn has_field_mask(&self) -> bool { + self.field_mask.is_some() + } + + // Param is passed by value, moved + pub fn set_field_mask(&mut self, v: ::protobuf::well_known_types::FieldMask) { + self.field_mask = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_field_mask(&mut self) -> &mut ::protobuf::well_known_types::FieldMask { + if self.field_mask.is_none() { + self.field_mask.set_default(); + } + self.field_mask.as_mut().unwrap() + } + + // Take field + pub fn take_field_mask(&mut self) -> ::protobuf::well_known_types::FieldMask { + self.field_mask.take().unwrap_or_else(|| ::protobuf::well_known_types::FieldMask::new()) + } +} + +impl ::protobuf::Message for UpdateInstanceRequest { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + for v in &self.field_mask { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.field_mask)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.field_mask.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.field_mask.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateInstanceRequest { + UpdateInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &UpdateInstanceRequest| { &m.instance }, + |m: &mut UpdateInstanceRequest| { &mut m.instance }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::FieldMask>>( + "field_mask", + |m: &UpdateInstanceRequest| { &m.field_mask }, + |m: &mut UpdateInstanceRequest| { &mut m.field_mask }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateInstanceRequest, + }; + unsafe { + instance.get(UpdateInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for UpdateInstanceRequest { + fn clear(&mut self) { + self.instance.clear(); + self.field_mask.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteInstanceRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteInstanceRequest { + fn default() -> &'a DeleteInstanceRequest { + ::default_instance() + } +} + +impl DeleteInstanceRequest { + pub fn new() -> DeleteInstanceRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteInstanceRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteInstanceRequest { + DeleteInstanceRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteInstanceRequest| { &m.name }, + |m: &mut DeleteInstanceRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteInstanceRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteInstanceRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteInstanceRequest, + }; + unsafe { + instance.get(DeleteInstanceRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteInstanceRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteInstanceRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteInstanceRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CreateInstanceMetadata { + // message fields + pub instance: ::protobuf::SingularPtrField, + pub start_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub cancel_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub end_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateInstanceMetadata { + fn default() -> &'a CreateInstanceMetadata { + ::default_instance() + } +} + +impl CreateInstanceMetadata { + pub fn new() -> CreateInstanceMetadata { + ::std::default::Default::default() + } + + // .google.spanner.admin.instance.v1.Instance instance = 1; + + + pub fn get_instance(&self) -> &Instance { + self.instance.as_ref().unwrap_or_else(|| Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> Instance { + self.instance.take().unwrap_or_else(|| Instance::new()) + } + + // .google.protobuf.Timestamp start_time = 2; + + + pub fn get_start_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.start_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_start_time(&mut self) { + self.start_time.clear(); + } + + pub fn has_start_time(&self) -> bool { + self.start_time.is_some() + } + + // Param is passed by value, moved + pub fn set_start_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.start_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_start_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.start_time.is_none() { + self.start_time.set_default(); + } + self.start_time.as_mut().unwrap() + } + + // Take field + pub fn take_start_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.start_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp cancel_time = 3; + + + pub fn get_cancel_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.cancel_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_cancel_time(&mut self) { + self.cancel_time.clear(); + } + + pub fn has_cancel_time(&self) -> bool { + self.cancel_time.is_some() + } + + // Param is passed by value, moved + pub fn set_cancel_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.cancel_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cancel_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.cancel_time.is_none() { + self.cancel_time.set_default(); + } + self.cancel_time.as_mut().unwrap() + } + + // Take field + pub fn take_cancel_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.cancel_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp end_time = 4; + + + pub fn get_end_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.end_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_end_time(&mut self) { + self.end_time.clear(); + } + + pub fn has_end_time(&self) -> bool { + self.end_time.is_some() + } + + // Param is passed by value, moved + pub fn set_end_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.end_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_end_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.end_time.is_none() { + self.end_time.set_default(); + } + self.end_time.as_mut().unwrap() + } + + // Take field + pub fn take_end_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.end_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CreateInstanceMetadata { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + for v in &self.start_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.cancel_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.end_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.start_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cancel_time)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.end_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.start_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.cancel_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.end_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.start_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.cancel_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.end_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateInstanceMetadata { + CreateInstanceMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &CreateInstanceMetadata| { &m.instance }, + |m: &mut CreateInstanceMetadata| { &mut m.instance }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "start_time", + |m: &CreateInstanceMetadata| { &m.start_time }, + |m: &mut CreateInstanceMetadata| { &mut m.start_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "cancel_time", + |m: &CreateInstanceMetadata| { &m.cancel_time }, + |m: &mut CreateInstanceMetadata| { &mut m.cancel_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "end_time", + |m: &CreateInstanceMetadata| { &m.end_time }, + |m: &mut CreateInstanceMetadata| { &mut m.end_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateInstanceMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateInstanceMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateInstanceMetadata, + }; + unsafe { + instance.get(CreateInstanceMetadata::new) + } + } +} + +impl ::protobuf::Clear for CreateInstanceMetadata { + fn clear(&mut self) { + self.instance.clear(); + self.start_time.clear(); + self.cancel_time.clear(); + self.end_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateInstanceMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateInstanceMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct UpdateInstanceMetadata { + // message fields + pub instance: ::protobuf::SingularPtrField, + pub start_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub cancel_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub end_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UpdateInstanceMetadata { + fn default() -> &'a UpdateInstanceMetadata { + ::default_instance() + } +} + +impl UpdateInstanceMetadata { + pub fn new() -> UpdateInstanceMetadata { + ::std::default::Default::default() + } + + // .google.spanner.admin.instance.v1.Instance instance = 1; + + + pub fn get_instance(&self) -> &Instance { + self.instance.as_ref().unwrap_or_else(|| Instance::default_instance()) + } + pub fn clear_instance(&mut self) { + self.instance.clear(); + } + + pub fn has_instance(&self) -> bool { + self.instance.is_some() + } + + // Param is passed by value, moved + pub fn set_instance(&mut self, v: Instance) { + self.instance = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_instance(&mut self) -> &mut Instance { + if self.instance.is_none() { + self.instance.set_default(); + } + self.instance.as_mut().unwrap() + } + + // Take field + pub fn take_instance(&mut self) -> Instance { + self.instance.take().unwrap_or_else(|| Instance::new()) + } + + // .google.protobuf.Timestamp start_time = 2; + + + pub fn get_start_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.start_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_start_time(&mut self) { + self.start_time.clear(); + } + + pub fn has_start_time(&self) -> bool { + self.start_time.is_some() + } + + // Param is passed by value, moved + pub fn set_start_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.start_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_start_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.start_time.is_none() { + self.start_time.set_default(); + } + self.start_time.as_mut().unwrap() + } + + // Take field + pub fn take_start_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.start_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp cancel_time = 3; + + + pub fn get_cancel_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.cancel_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_cancel_time(&mut self) { + self.cancel_time.clear(); + } + + pub fn has_cancel_time(&self) -> bool { + self.cancel_time.is_some() + } + + // Param is passed by value, moved + pub fn set_cancel_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.cancel_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cancel_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.cancel_time.is_none() { + self.cancel_time.set_default(); + } + self.cancel_time.as_mut().unwrap() + } + + // Take field + pub fn take_cancel_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.cancel_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp end_time = 4; + + + pub fn get_end_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.end_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_end_time(&mut self) { + self.end_time.clear(); + } + + pub fn has_end_time(&self) -> bool { + self.end_time.is_some() + } + + // Param is passed by value, moved + pub fn set_end_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.end_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_end_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.end_time.is_none() { + self.end_time.set_default(); + } + self.end_time.as_mut().unwrap() + } + + // Take field + pub fn take_end_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.end_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for UpdateInstanceMetadata { + fn is_initialized(&self) -> bool { + for v in &self.instance { + if !v.is_initialized() { + return false; + } + }; + for v in &self.start_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.cancel_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.end_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.instance)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.start_time)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cancel_time)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.end_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.instance.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.start_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.cancel_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.end_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.instance.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.start_time.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.cancel_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.end_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UpdateInstanceMetadata { + UpdateInstanceMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "instance", + |m: &UpdateInstanceMetadata| { &m.instance }, + |m: &mut UpdateInstanceMetadata| { &mut m.instance }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "start_time", + |m: &UpdateInstanceMetadata| { &m.start_time }, + |m: &mut UpdateInstanceMetadata| { &mut m.start_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "cancel_time", + |m: &UpdateInstanceMetadata| { &m.cancel_time }, + |m: &mut UpdateInstanceMetadata| { &mut m.cancel_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "end_time", + |m: &UpdateInstanceMetadata| { &m.end_time }, + |m: &mut UpdateInstanceMetadata| { &mut m.end_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "UpdateInstanceMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UpdateInstanceMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const UpdateInstanceMetadata, + }; + unsafe { + instance.get(UpdateInstanceMetadata::new) + } + } +} + +impl ::protobuf::Clear for UpdateInstanceMetadata { + fn clear(&mut self) { + self.instance.clear(); + self.start_time.clear(); + self.cancel_time.clear(); + self.end_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UpdateInstanceMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UpdateInstanceMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n=google/spanner/admin/instance/v1/spanner_instance_admin.proto\x12\x20\ + google.spanner.admin.instance.v1\x1a\x1cgoogle/api/annotations.proto\x1a\ + \x1egoogle/iam/v1/iam_policy.proto\x1a\x1agoogle/iam/v1/policy.proto\x1a\ + #google/longrunning/operations.proto\x1a\x1bgoogle/protobuf/empty.proto\ + \x1a\x20google/protobuf/field_mask.proto\x1a\x1fgoogle/protobuf/timestam\ + p.proto\"G\n\x0eInstanceConfig\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04\ + name\x12!\n\x0cdisplay_name\x18\x02\x20\x01(\tR\x0bdisplayName\"\x84\x03\ + \n\x08Instance\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x16\n\ + \x06config\x18\x02\x20\x01(\tR\x06config\x12!\n\x0cdisplay_name\x18\x03\ + \x20\x01(\tR\x0bdisplayName\x12\x1d\n\nnode_count\x18\x05\x20\x01(\x05R\ + \tnodeCount\x12F\n\x05state\x18\x06\x20\x01(\x0e20.google.spanner.admin.\ + instance.v1.Instance.StateR\x05state\x12N\n\x06labels\x18\x07\x20\x03(\ + \x0b26.google.spanner.admin.instance.v1.Instance.LabelsEntryR\x06labels\ + \x1a9\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\ + \x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"7\n\x05State\x12\ + \x15\n\x11STATE_UNSPECIFIED\x10\0\x12\x0c\n\x08CREATING\x10\x01\x12\t\n\ + \x05READY\x10\x02\"p\n\x1aListInstanceConfigsRequest\x12\x16\n\x06parent\ + \x18\x01\x20\x01(\tR\x06parent\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05\ + R\x08pageSize\x12\x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\xa2\ + \x01\n\x1bListInstanceConfigsResponse\x12[\n\x10instance_configs\x18\x01\ + \x20\x03(\x0b20.google.spanner.admin.instance.v1.InstanceConfigR\x0finst\ + anceConfigs\x12&\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\ + \".\n\x18GetInstanceConfigRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\ + \x04name\"(\n\x12GetInstanceRequest\x12\x12\n\x04name\x18\x01\x20\x01(\t\ + R\x04name\"\x98\x01\n\x15CreateInstanceRequest\x12\x16\n\x06parent\x18\ + \x01\x20\x01(\tR\x06parent\x12\x1f\n\x0binstance_id\x18\x02\x20\x01(\tR\ + \ninstanceId\x12F\n\x08instance\x18\x03\x20\x01(\x0b2*.google.spanner.ad\ + min.instance.v1.InstanceR\x08instance\"\x82\x01\n\x14ListInstancesReques\ + t\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x1b\n\tpage_size\ + \x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x03\x20\x01\ + (\tR\tpageToken\x12\x16\n\x06filter\x18\x04\x20\x01(\tR\x06filter\"\x89\ + \x01\n\x15ListInstancesResponse\x12H\n\tinstances\x18\x01\x20\x03(\x0b2*\ + .google.spanner.admin.instance.v1.InstanceR\tinstances\x12&\n\x0fnext_pa\ + ge_token\x18\x02\x20\x01(\tR\rnextPageToken\"\x9a\x01\n\x15UpdateInstanc\ + eRequest\x12F\n\x08instance\x18\x01\x20\x01(\x0b2*.google.spanner.admin.\ + instance.v1.InstanceR\x08instance\x129\n\nfield_mask\x18\x02\x20\x01(\ + \x0b2\x1a.google.protobuf.FieldMaskR\tfieldMask\"+\n\x15DeleteInstanceRe\ + quest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\x8f\x02\n\x16Creat\ + eInstanceMetadata\x12F\n\x08instance\x18\x01\x20\x01(\x0b2*.google.spann\ + er.admin.instance.v1.InstanceR\x08instance\x129\n\nstart_time\x18\x02\ + \x20\x01(\x0b2\x1a.google.protobuf.TimestampR\tstartTime\x12;\n\x0bcance\ + l_time\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ncancelTime\ + \x125\n\x08end_time\x18\x04\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\ + \x07endTime\"\x8f\x02\n\x16UpdateInstanceMetadata\x12F\n\x08instance\x18\ + \x01\x20\x01(\x0b2*.google.spanner.admin.instance.v1.InstanceR\x08instan\ + ce\x129\n\nstart_time\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.Timestam\ + pR\tstartTime\x12;\n\x0bcancel_time\x18\x03\x20\x01(\x0b2\x1a.google.pro\ + tobuf.TimestampR\ncancelTime\x125\n\x08end_time\x18\x04\x20\x01(\x0b2\ + \x1a.google.protobuf.TimestampR\x07endTime2\xe6\x0c\n\rInstanceAdmin\x12\ + \xc3\x01\n\x13ListInstanceConfigs\x12<.google.spanner.admin.instance.v1.\ + ListInstanceConfigsRequest\x1a=.google.spanner.admin.instance.v1.ListIns\ + tanceConfigsResponse\"/\x82\xd3\xe4\x93\x02)\x12'/v1/{parent=projects/*}\ + /instanceConfigs\x12\xb2\x01\n\x11GetInstanceConfig\x12:.google.spanner.\ + admin.instance.v1.GetInstanceConfigRequest\x1a0.google.spanner.admin.ins\ + tance.v1.InstanceConfig\"/\x82\xd3\xe4\x93\x02)\x12'/v1/{name=projects/*\ + /instanceConfigs/*}\x12\xab\x01\n\rListInstances\x126.google.spanner.adm\ + in.instance.v1.ListInstancesRequest\x1a7.google.spanner.admin.instance.v\ + 1.ListInstancesResponse\")\x82\xd3\xe4\x93\x02#\x12!/v1/{parent=projects\ + /*}/instances\x12\x9a\x01\n\x0bGetInstance\x124.google.spanner.admin.ins\ + tance.v1.GetInstanceRequest\x1a*.google.spanner.admin.instance.v1.Instan\ + ce\")\x82\xd3\xe4\x93\x02#\x12!/v1/{name=projects/*/instances/*}\x12\x96\ + \x01\n\x0eCreateInstance\x127.google.spanner.admin.instance.v1.CreateIns\ + tanceRequest\x1a\x1d.google.longrunning.Operation\",\x82\xd3\xe4\x93\x02\ + &\"!/v1/{parent=projects/*}/instances:\x01*\x12\x9f\x01\n\x0eUpdateInsta\ + nce\x127.google.spanner.admin.instance.v1.UpdateInstanceRequest\x1a\x1d.\ + google.longrunning.Operation\"5\x82\xd3\xe4\x93\x02/2*/v1/{instance.name\ + =projects/*/instances/*}:\x01*\x12\x8c\x01\n\x0eDeleteInstance\x127.goog\ + le.spanner.admin.instance.v1.DeleteInstanceRequest\x1a\x16.google.protob\ + uf.Empty\")\x82\xd3\xe4\x93\x02#*!/v1/{name=projects/*/instances/*}\x12\ + \x88\x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRequest\x1a\ + \x15.google.iam.v1.Policy\"=\x82\xd3\xe4\x93\x027\"2/v1/{resource=projec\ + ts/*/instances/*}:setIamPolicy:\x01*\x12\x88\x01\n\x0cGetIamPolicy\x12\"\ + .google.iam.v1.GetIamPolicyRequest\x1a\x15.google.iam.v1.Policy\"=\x82\ + \xd3\xe4\x93\x027\"2/v1/{resource=projects/*/instances/*}:getIamPolicy:\ + \x01*\x12\xae\x01\n\x12TestIamPermissions\x12(.google.iam.v1.TestIamPerm\ + issionsRequest\x1a).google.iam.v1.TestIamPermissionsResponse\"C\x82\xd3\ + \xe4\x93\x02=\"8/v1/{resource=projects/*/instances/*}:testIamPermissions\ + :\x01*B\xdf\x01\n$com.google.spanner.admin.instance.v1B\x19SpannerInstan\ + ceAdminProtoP\x01ZHgoogle.golang.org/genproto/googleapis/spanner/admin/i\ + nstance/v1;instance\xaa\x02&Google.Cloud.Spanner.Admin.Instance.V1\xca\ + \x02&Google\\Cloud\\Spanner\\Admin\\Instance\\V1J\xa6\x9b\x01\n\x07\x12\ + \x05\x0e\0\xda\x03\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\ + \x20Copyright\x202018\x20Google\x20LLC\n\n\x20Licensed\x20under\x20the\ + \x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20y\ + ou\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20compliance\ + \x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\ + \x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/li\ + censes/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\ + \x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\ + \x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20\ + IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20A\ + NY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20Li\ + cense\x20for\x20the\x20specific\x20language\x20governing\x20permissions\ + \x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\ + \x12\x03\x10\0)\n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\ + \x13\0(\n\t\n\x02\x03\x02\x12\x03\x14\0$\n\t\n\x02\x03\x03\x12\x03\x15\0\ + -\n\t\n\x02\x03\x04\x12\x03\x16\0%\n\t\n\x02\x03\x05\x12\x03\x17\0*\n\t\ + \n\x02\x03\x06\x12\x03\x18\0)\n\x08\n\x01\x08\x12\x03\x1a\0C\n\t\n\x02\ + \x08%\x12\x03\x1a\0C\n\x08\n\x01\x08\x12\x03\x1b\0_\n\t\n\x02\x08\x0b\ + \x12\x03\x1b\0_\n\x08\n\x01\x08\x12\x03\x1c\0\"\n\t\n\x02\x08\n\x12\x03\ + \x1c\0\"\n\x08\n\x01\x08\x12\x03\x1d\0:\n\t\n\x02\x08\x08\x12\x03\x1d\0:\ + \n\x08\n\x01\x08\x12\x03\x1e\0=\n\t\n\x02\x08\x01\x12\x03\x1e\0=\n\x08\n\ + \x01\x08\x12\x03\x1f\0E\n\t\n\x02\x08)\x12\x03\x1f\0E\n\xdd\x08\n\x02\ + \x06\0\x12\x057\0\xe1\x01\x01\x1a\xcf\x08\x20Cloud\x20Spanner\x20Instanc\ + e\x20Admin\x20API\n\n\x20The\x20Cloud\x20Spanner\x20Instance\x20Admin\ + \x20API\x20can\x20be\x20used\x20to\x20create,\x20delete,\n\x20modify\x20\ + and\x20list\x20instances.\x20Instances\x20are\x20dedicated\x20Cloud\x20S\ + panner\x20serving\n\x20and\x20storage\x20resources\x20to\x20be\x20used\ + \x20by\x20Cloud\x20Spanner\x20databases.\n\n\x20Each\x20instance\x20has\ + \x20a\x20\"configuration\",\x20which\x20dictates\x20where\x20the\n\x20se\ + rving\x20resources\x20for\x20the\x20Cloud\x20Spanner\x20instance\x20are\ + \x20located\x20(e.g.,\n\x20US-central,\x20Europe).\x20Configurations\x20\ + are\x20created\x20by\x20Google\x20based\x20on\n\x20resource\x20availabil\ + ity.\n\n\x20Cloud\x20Spanner\x20billing\x20is\x20based\x20on\x20the\x20i\ + nstances\x20that\x20exist\x20and\x20their\n\x20sizes.\x20After\x20an\x20\ + instance\x20exists,\x20there\x20are\x20no\x20additional\n\x20per-databas\ + e\x20or\x20per-operation\x20charges\x20for\x20use\x20of\x20the\x20instan\ + ce\n\x20(though\x20there\x20may\x20be\x20additional\x20network\x20bandwi\ + dth\x20charges).\n\x20Instances\x20offer\x20isolation:\x20problems\x20wi\ + th\x20databases\x20in\x20one\x20instance\n\x20will\x20not\x20affect\x20o\ + ther\x20instances.\x20However,\x20within\x20an\x20instance\n\x20database\ + s\x20can\x20affect\x20each\x20other.\x20For\x20example,\x20if\x20one\x20\ + database\x20in\x20an\n\x20instance\x20receives\x20a\x20lot\x20of\x20requ\ + ests\x20and\x20consumes\x20most\x20of\x20the\n\x20instance\x20resources,\ + \x20fewer\x20resources\x20are\x20available\x20for\x20other\n\x20database\ + s\x20in\x20that\x20instance,\x20and\x20their\x20performance\x20may\x20su\ + ffer.\n\n\n\n\x03\x06\0\x01\x12\x037\x08\x15\nP\n\x04\x06\0\x02\0\x12\ + \x049\x02=\x03\x1aB\x20Lists\x20the\x20supported\x20instance\x20configur\ + ations\x20for\x20a\x20given\x20project.\n\n\x0c\n\x05\x06\0\x02\0\x01\ + \x12\x039\x06\x19\n\x0c\n\x05\x06\0\x02\0\x02\x12\x039\x1a4\n\x0c\n\x05\ + \x06\0\x02\0\x03\x12\x039?Z\n\r\n\x05\x06\0\x02\0\x04\x12\x04:\x04<\x06\ + \n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04:\x04<\x06\nK\n\x04\x06\ + \0\x02\x01\x12\x04@\x02D\x03\x1a=\x20Gets\x20information\x20about\x20a\ + \x20particular\x20instance\x20configuration.\n\n\x0c\n\x05\x06\0\x02\x01\ + \x01\x12\x03@\x06\x17\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03@\x180\n\x0c\ + \n\x05\x06\0\x02\x01\x03\x12\x03@;I\n\r\n\x05\x06\0\x02\x01\x04\x12\x04A\ + \x04C\x06\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x04A\x04C\x06\n9\ + \n\x04\x06\0\x02\x02\x12\x04G\x02K\x03\x1a+\x20Lists\x20all\x20instances\ + \x20in\x20the\x20given\x20project.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\ + \x03G\x06\x13\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03G\x14(\n\x0c\n\x05\ + \x06\0\x02\x02\x03\x12\x03G3H\n\r\n\x05\x06\0\x02\x02\x04\x12\x04H\x04J\ + \x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04H\x04J\x06\n=\n\ + \x04\x06\0\x02\x03\x12\x04N\x02R\x03\x1a/\x20Gets\x20information\x20abou\ + t\x20a\x20particular\x20instance.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\ + \x03N\x06\x11\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03N\x12$\n\x0c\n\x05\ + \x06\0\x02\x03\x03\x12\x03N/7\n\r\n\x05\x06\0\x02\x03\x04\x12\x04O\x04Q\ + \x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04O\x04Q\x06\n\xa8\ + \x0c\n\x04\x06\0\x02\x04\x12\x04v\x02{\x03\x1a\x99\x0c\x20Creates\x20an\ + \x20instance\x20and\x20begins\x20preparing\x20it\x20to\x20begin\x20servi\ + ng.\x20The\n\x20returned\x20[long-running\x20operation][google.longrunni\ + ng.Operation]\n\x20can\x20be\x20used\x20to\x20track\x20the\x20progress\ + \x20of\x20preparing\x20the\x20new\n\x20instance.\x20The\x20instance\x20n\ + ame\x20is\x20assigned\x20by\x20the\x20caller.\x20If\x20the\n\x20named\ + \x20instance\x20already\x20exists,\x20`CreateInstance`\x20returns\n\x20`\ + ALREADY_EXISTS`.\n\n\x20Immediately\x20upon\x20completion\x20of\x20this\ + \x20request:\n\n\x20\x20\x20*\x20The\x20instance\x20is\x20readable\x20vi\ + a\x20the\x20API,\x20with\x20all\x20requested\x20attributes\n\x20\x20\x20\ + \x20\x20but\x20no\x20allocated\x20resources.\x20Its\x20state\x20is\x20`C\ + REATING`.\n\n\x20Until\x20completion\x20of\x20the\x20returned\x20operati\ + on:\n\n\x20\x20\x20*\x20Cancelling\x20the\x20operation\x20renders\x20the\ + \x20instance\x20immediately\x20unreadable\n\x20\x20\x20\x20\x20via\x20th\ + e\x20API.\n\x20\x20\x20*\x20The\x20instance\x20can\x20be\x20deleted.\n\ + \x20\x20\x20*\x20All\x20other\x20attempts\x20to\x20modify\x20the\x20inst\ + ance\x20are\x20rejected.\n\n\x20Upon\x20completion\x20of\x20the\x20retur\ + ned\x20operation:\n\n\x20\x20\x20*\x20Billing\x20for\x20all\x20successfu\ + lly-allocated\x20resources\x20begins\x20(some\x20types\n\x20\x20\x20\x20\ + \x20may\x20have\x20lower\x20than\x20the\x20requested\x20levels).\n\x20\ + \x20\x20*\x20Databases\x20can\x20be\x20created\x20in\x20the\x20instance.\ + \n\x20\x20\x20*\x20The\x20instance's\x20allocated\x20resource\x20levels\ + \x20are\x20readable\x20via\x20the\x20API.\n\x20\x20\x20*\x20The\x20insta\ + nce's\x20state\x20becomes\x20`READY`.\n\n\x20The\x20returned\x20[long-ru\ + nning\x20operation][google.longrunning.Operation]\x20will\n\x20have\x20a\ + \x20name\x20of\x20the\x20format\x20`/operations/`\x20and\n\x20can\x20be\x20used\x20to\x20track\x20creation\x20of\ + \x20the\x20instance.\x20\x20The\n\x20[metadata][google.longrunning.Opera\ + tion.metadata]\x20field\x20type\x20is\n\x20[CreateInstanceMetadata][goog\ + le.spanner.admin.instance.v1.CreateInstanceMetadata].\n\x20The\x20[respo\ + nse][google.longrunning.Operation.response]\x20field\x20type\x20is\n\x20\ + [Instance][google.spanner.admin.instance.v1.Instance],\x20if\x20successf\ + ul.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03v\x06\x14\n\x0c\n\x05\x06\0\ + \x02\x04\x02\x12\x03v\x15*\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03v5Q\n\r\ + \n\x05\x06\0\x02\x04\x04\x12\x04w\x04z\x06\n\x11\n\t\x06\0\x02\x04\x04\ + \xb0\xca\xbc\"\x12\x04w\x04z\x06\n\xb8\x0f\n\x04\x06\0\x02\x05\x12\x06\ + \xa5\x01\x02\xaa\x01\x03\x1a\xa7\x0f\x20Updates\x20an\x20instance,\x20an\ + d\x20begins\x20allocating\x20or\x20releasing\x20resources\n\x20as\x20req\ + uested.\x20The\x20returned\x20[long-running\n\x20operation][google.longr\ + unning.Operation]\x20can\x20be\x20used\x20to\x20track\x20the\n\x20progre\ + ss\x20of\x20updating\x20the\x20instance.\x20If\x20the\x20named\x20instan\ + ce\x20does\x20not\n\x20exist,\x20returns\x20`NOT_FOUND`.\n\n\x20Immediat\ + ely\x20upon\x20completion\x20of\x20this\x20request:\n\n\x20\x20\x20*\x20\ + For\x20resource\x20types\x20for\x20which\x20a\x20decrease\x20in\x20the\ + \x20instance's\x20allocation\n\x20\x20\x20\x20\x20has\x20been\x20request\ + ed,\x20billing\x20is\x20based\x20on\x20the\x20newly-requested\x20level.\ + \n\n\x20Until\x20completion\x20of\x20the\x20returned\x20operation:\n\n\ + \x20\x20\x20*\x20Cancelling\x20the\x20operation\x20sets\x20its\x20metada\ + ta's\n\x20\x20\x20\x20\x20[cancel_time][google.spanner.admin.instance.v1\ + .UpdateInstanceMetadata.cancel_time],\x20and\x20begins\n\x20\x20\x20\x20\ + \x20restoring\x20resources\x20to\x20their\x20pre-request\x20values.\x20T\ + he\x20operation\n\x20\x20\x20\x20\x20is\x20guaranteed\x20to\x20succeed\ + \x20at\x20undoing\x20all\x20resource\x20changes,\n\x20\x20\x20\x20\x20af\ + ter\x20which\x20point\x20it\x20terminates\x20with\x20a\x20`CANCELLED`\ + \x20status.\n\x20\x20\x20*\x20All\x20other\x20attempts\x20to\x20modify\ + \x20the\x20instance\x20are\x20rejected.\n\x20\x20\x20*\x20Reading\x20the\ + \x20instance\x20via\x20the\x20API\x20continues\x20to\x20give\x20the\x20p\ + re-request\n\x20\x20\x20\x20\x20resource\x20levels.\n\n\x20Upon\x20compl\ + etion\x20of\x20the\x20returned\x20operation:\n\n\x20\x20\x20*\x20Billing\ + \x20begins\x20for\x20all\x20successfully-allocated\x20resources\x20(some\ + \x20types\n\x20\x20\x20\x20\x20may\x20have\x20lower\x20than\x20the\x20re\ + quested\x20levels).\n\x20\x20\x20*\x20All\x20newly-reserved\x20resources\ + \x20are\x20available\x20for\x20serving\x20the\x20instance's\n\x20\x20\ + \x20\x20\x20tables.\n\x20\x20\x20*\x20The\x20instance's\x20new\x20resour\ + ce\x20levels\x20are\x20readable\x20via\x20the\x20API.\n\n\x20The\x20retu\ + rned\x20[long-running\x20operation][google.longrunning.Operation]\x20wil\ + l\n\x20have\x20a\x20name\x20of\x20the\x20format\x20`/oper\ + ations/`\x20and\n\x20can\x20be\x20used\x20to\x20track\x20t\ + he\x20instance\x20modification.\x20\x20The\n\x20[metadata][google.longru\ + nning.Operation.metadata]\x20field\x20type\x20is\n\x20[UpdateInstanceMet\ + adata][google.spanner.admin.instance.v1.UpdateInstanceMetadata].\n\x20Th\ + e\x20[response][google.longrunning.Operation.response]\x20field\x20type\ + \x20is\n\x20[Instance][google.spanner.admin.instance.v1.Instance],\x20if\ + \x20successful.\n\n\x20Authorization\x20requires\x20`spanner.instances.u\ + pdate`\x20permission\x20on\n\x20resource\x20[name][google.spanner.admin.\ + instance.v1.Instance.name].\n\n\r\n\x05\x06\0\x02\x05\x01\x12\x04\xa5\ + \x01\x06\x14\n\r\n\x05\x06\0\x02\x05\x02\x12\x04\xa5\x01\x15*\n\r\n\x05\ + \x06\0\x02\x05\x03\x12\x04\xa5\x015Q\n\x0f\n\x05\x06\0\x02\x05\x04\x12\ + \x06\xa6\x01\x04\xa9\x01\x06\n\x13\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\"\ + \x12\x06\xa6\x01\x04\xa9\x01\x06\n\xc8\x02\n\x04\x06\0\x02\x06\x12\x06\ + \xb7\x01\x02\xbb\x01\x03\x1a\xb7\x02\x20Deletes\x20an\x20instance.\n\n\ + \x20Immediately\x20upon\x20completion\x20of\x20the\x20request:\n\n\x20\ + \x20\x20*\x20Billing\x20ceases\x20for\x20all\x20of\x20the\x20instance's\ + \x20reserved\x20resources.\n\n\x20Soon\x20afterward:\n\n\x20\x20\x20*\ + \x20The\x20instance\x20and\x20*all\x20of\x20its\x20databases*\x20immedia\ + tely\x20and\n\x20\x20\x20\x20\x20irrevocably\x20disappear\x20from\x20the\ + \x20API.\x20All\x20data\x20in\x20the\x20databases\n\x20\x20\x20\x20\x20i\ + s\x20permanently\x20deleted.\n\n\r\n\x05\x06\0\x02\x06\x01\x12\x04\xb7\ + \x01\x06\x14\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\xb7\x01\x15*\n\r\n\x05\ + \x06\0\x02\x06\x03\x12\x04\xb7\x015J\n\x0f\n\x05\x06\0\x02\x06\x04\x12\ + \x06\xb8\x01\x04\xba\x01\x06\n\x13\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\ + \x12\x06\xb8\x01\x04\xba\x01\x06\n\xdf\x01\n\x04\x06\0\x02\x07\x12\x06\ + \xc2\x01\x02\xc7\x01\x03\x1a\xce\x01\x20Sets\x20the\x20access\x20control\ + \x20policy\x20on\x20an\x20instance\x20resource.\x20Replaces\x20any\n\x20\ + existing\x20policy.\n\n\x20Authorization\x20requires\x20`spanner.instanc\ + es.setIamPolicy`\x20on\n\x20[resource][google.iam.v1.SetIamPolicyRequest\ + .resource].\n\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xc2\x01\x06\x12\n\r\n\ + \x05\x06\0\x02\x07\x02\x12\x04\xc2\x01\x134\n\r\n\x05\x06\0\x02\x07\x03\ + \x12\x04\xc2\x01?S\n\x0f\n\x05\x06\0\x02\x07\x04\x12\x06\xc3\x01\x04\xc6\ + \x01\x06\n\x13\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x06\xc3\x01\x04\ + \xc6\x01\x06\n\x90\x02\n\x04\x06\0\x02\x08\x12\x06\xce\x01\x02\xd3\x01\ + \x03\x1a\xff\x01\x20Gets\x20the\x20access\x20control\x20policy\x20for\ + \x20an\x20instance\x20resource.\x20Returns\x20an\x20empty\n\x20policy\ + \x20if\x20an\x20instance\x20exists\x20but\x20does\x20not\x20have\x20a\ + \x20policy\x20set.\n\n\x20Authorization\x20requires\x20`spanner.instance\ + s.getIamPolicy`\x20on\n\x20[resource][google.iam.v1.GetIamPolicyRequest.\ + resource].\n\n\r\n\x05\x06\0\x02\x08\x01\x12\x04\xce\x01\x06\x12\n\r\n\ + \x05\x06\0\x02\x08\x02\x12\x04\xce\x01\x134\n\r\n\x05\x06\0\x02\x08\x03\ + \x12\x04\xce\x01?S\n\x0f\n\x05\x06\0\x02\x08\x04\x12\x06\xcf\x01\x04\xd2\ + \x01\x06\n\x13\n\t\x06\0\x02\x08\x04\xb0\xca\xbc\"\x12\x06\xcf\x01\x04\ + \xd2\x01\x06\n\xd5\x02\n\x04\x06\0\x02\t\x12\x06\xdb\x01\x02\xe0\x01\x03\ + \x1a\xc4\x02\x20Returns\x20permissions\x20that\x20the\x20caller\x20has\ + \x20on\x20the\x20specified\x20instance\x20resource.\n\n\x20Attempting\ + \x20this\x20RPC\x20on\x20a\x20non-existent\x20Cloud\x20Spanner\x20instan\ + ce\x20resource\x20will\n\x20result\x20in\x20a\x20NOT_FOUND\x20error\x20i\ + f\x20the\x20user\x20has\x20`spanner.instances.list`\n\x20permission\x20o\ + n\x20the\x20containing\x20Google\x20Cloud\x20Project.\x20Otherwise\x20re\ + turns\x20an\n\x20empty\x20set\x20of\x20permissions.\n\n\r\n\x05\x06\0\ + \x02\t\x01\x12\x04\xdb\x01\x06\x18\n\r\n\x05\x06\0\x02\t\x02\x12\x04\xdb\ + \x01\x19@\n\r\n\x05\x06\0\x02\t\x03\x12\x04\xdb\x01Ks\n\x0f\n\x05\x06\0\ + \x02\t\x04\x12\x06\xdc\x01\x04\xdf\x01\x06\n\x13\n\t\x06\0\x02\t\x04\xb0\ + \xca\xbc\"\x12\x06\xdc\x01\x04\xdf\x01\x06\n\x97\x01\n\x02\x04\0\x12\x06\ + \xe5\x01\0\xed\x01\x01\x1a\x88\x01\x20A\x20possible\x20configuration\x20\ + for\x20a\x20Cloud\x20Spanner\x20instance.\x20Configurations\n\x20define\ + \x20the\x20geographic\x20placement\x20of\x20nodes\x20and\x20their\x20rep\ + lication.\n\n\x0b\n\x03\x04\0\x01\x12\x04\xe5\x01\x08\x16\n\x93\x01\n\ + \x04\x04\0\x02\0\x12\x04\xe9\x01\x02\x12\x1a\x84\x01\x20A\x20unique\x20i\ + dentifier\x20for\x20the\x20instance\x20configuration.\x20\x20Values\n\ + \x20are\x20of\x20the\x20form\n\x20`projects//instanceConfigs/[a\ + -z][-a-z0-9]*`\n\n\x0f\n\x05\x04\0\x02\0\x04\x12\x06\xe9\x01\x02\xe5\x01\ + \x18\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xe9\x01\x02\x08\n\r\n\x05\x04\0\ + \x02\0\x01\x12\x04\xe9\x01\t\r\n\r\n\x05\x04\0\x02\0\x03\x12\x04\xe9\x01\ + \x10\x11\nM\n\x04\x04\0\x02\x01\x12\x04\xec\x01\x02\x1a\x1a?\x20The\x20n\ + ame\x20of\x20this\x20instance\x20configuration\x20as\x20it\x20appears\ + \x20in\x20UIs.\n\n\x0f\n\x05\x04\0\x02\x01\x04\x12\x06\xec\x01\x02\xe9\ + \x01\x12\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\xec\x01\x02\x08\n\r\n\x05\ + \x04\0\x02\x01\x01\x12\x04\xec\x01\t\x15\n\r\n\x05\x04\0\x02\x01\x03\x12\ + \x04\xec\x01\x18\x19\n\\\n\x02\x04\x01\x12\x06\xf0\x01\0\xb4\x02\x01\x1a\ + N\x20An\x20isolated\x20set\x20of\x20Cloud\x20Spanner\x20resources\x20on\ + \x20which\x20databases\x20can\x20be\x20hosted.\n\n\x0b\n\x03\x04\x01\x01\ + \x12\x04\xf0\x01\x08\x10\n>\n\x04\x04\x01\x04\0\x12\x06\xf2\x01\x02\xfe\ + \x01\x03\x1a.\x20Indicates\x20the\x20current\x20state\x20of\x20the\x20in\ + stance.\n\n\r\n\x05\x04\x01\x04\0\x01\x12\x04\xf2\x01\x07\x0c\n\x20\n\ + \x06\x04\x01\x04\0\x02\0\x12\x04\xf4\x01\x04\x1a\x1a\x10\x20Not\x20speci\ + fied.\n\n\x0f\n\x07\x04\x01\x04\0\x02\0\x01\x12\x04\xf4\x01\x04\x15\n\ + \x0f\n\x07\x04\x01\x04\0\x02\0\x02\x12\x04\xf4\x01\x18\x19\n\x94\x01\n\ + \x06\x04\x01\x04\0\x02\x01\x12\x04\xf9\x01\x04\x11\x1a\x83\x01\x20The\ + \x20instance\x20is\x20still\x20being\x20created.\x20Resources\x20may\x20\ + not\x20be\n\x20available\x20yet,\x20and\x20operations\x20such\x20as\x20d\ + atabase\x20creation\x20may\x20not\n\x20work.\n\n\x0f\n\x07\x04\x01\x04\0\ + \x02\x01\x01\x12\x04\xf9\x01\x04\x0c\n\x0f\n\x07\x04\x01\x04\0\x02\x01\ + \x02\x12\x04\xf9\x01\x0f\x10\na\n\x06\x04\x01\x04\0\x02\x02\x12\x04\xfd\ + \x01\x04\x0e\x1aQ\x20The\x20instance\x20is\x20fully\x20created\x20and\ + \x20ready\x20to\x20do\x20work\x20such\x20as\n\x20creating\x20databases.\ + \n\n\x0f\n\x07\x04\x01\x04\0\x02\x02\x01\x12\x04\xfd\x01\x04\t\n\x0f\n\ + \x07\x04\x01\x04\0\x02\x02\x02\x12\x04\xfd\x01\x0c\r\n\x96\x02\n\x04\x04\ + \x01\x02\0\x12\x04\x84\x02\x02\x12\x1a\x87\x02\x20Required.\x20A\x20uniq\ + ue\x20identifier\x20for\x20the\x20instance,\x20which\x20cannot\x20be\x20\ + changed\n\x20after\x20the\x20instance\x20is\x20created.\x20Values\x20are\ + \x20of\x20the\x20form\n\x20`projects//instances/[a-z][-a-z0-9]*\ + [a-z0-9]`.\x20The\x20final\n\x20segment\x20of\x20the\x20name\x20must\x20\ + be\x20between\x206\x20and\x2030\x20characters\x20in\x20length.\n\n\x0f\n\ + \x05\x04\x01\x02\0\x04\x12\x06\x84\x02\x02\xfe\x01\x03\n\r\n\x05\x04\x01\ + \x02\0\x05\x12\x04\x84\x02\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\ + \x84\x02\t\r\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\x84\x02\x10\x11\n\xbe\ + \x02\n\x04\x04\x01\x02\x01\x12\x04\x8a\x02\x02\x14\x1a\xaf\x02\x20Requir\ + ed.\x20The\x20name\x20of\x20the\x20instance's\x20configuration.\x20Value\ + s\x20are\x20of\x20the\x20form\n\x20`projects//instanceConfigs/<\ + configuration>`.\x20See\n\x20also\x20[InstanceConfig][google.spanner.adm\ + in.instance.v1.InstanceConfig]\x20and\n\x20[ListInstanceConfigs][google.\ + spanner.admin.instance.v1.InstanceAdmin.ListInstanceConfigs].\n\n\x0f\n\ + \x05\x04\x01\x02\x01\x04\x12\x06\x8a\x02\x02\x84\x02\x12\n\r\n\x05\x04\ + \x01\x02\x01\x05\x12\x04\x8a\x02\x02\x08\n\r\n\x05\x04\x01\x02\x01\x01\ + \x12\x04\x8a\x02\t\x0f\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\x8a\x02\x12\ + \x13\n\x9e\x01\n\x04\x04\x01\x02\x02\x12\x04\x8e\x02\x02\x1a\x1a\x8f\x01\ + \x20Required.\x20The\x20descriptive\x20name\x20for\x20this\x20instance\ + \x20as\x20it\x20appears\x20in\x20UIs.\n\x20Must\x20be\x20unique\x20per\ + \x20project\x20and\x20between\x204\x20and\x2030\x20characters\x20in\x20l\ + ength.\n\n\x0f\n\x05\x04\x01\x02\x02\x04\x12\x06\x8e\x02\x02\x8a\x02\x14\ + \n\r\n\x05\x04\x01\x02\x02\x05\x12\x04\x8e\x02\x02\x08\n\r\n\x05\x04\x01\ + \x02\x02\x01\x12\x04\x8e\x02\t\x15\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\ + \x8e\x02\x18\x19\n\x97\x02\n\x04\x04\x01\x02\x03\x12\x04\x95\x02\x02\x17\ + \x1a\x88\x02\x20Required.\x20The\x20number\x20of\x20nodes\x20allocated\ + \x20to\x20this\x20instance.\x20This\x20may\x20be\x20zero\n\x20in\x20API\ + \x20responses\x20for\x20instances\x20that\x20are\x20not\x20yet\x20in\x20\ + state\x20`READY`.\n\n\x20See\x20[the\x20documentation](https://cloud.goo\ + gle.com/spanner/docs/instances#node_count)\n\x20for\x20more\x20informati\ + on\x20about\x20nodes.\n\n\x0f\n\x05\x04\x01\x02\x03\x04\x12\x06\x95\x02\ + \x02\x8e\x02\x1a\n\r\n\x05\x04\x01\x02\x03\x05\x12\x04\x95\x02\x02\x07\n\ + \r\n\x05\x04\x01\x02\x03\x01\x12\x04\x95\x02\x08\x12\n\r\n\x05\x04\x01\ + \x02\x03\x03\x12\x04\x95\x02\x15\x16\n\xd2\x02\n\x04\x04\x01\x02\x04\x12\ + \x04\x9c\x02\x02\x12\x1a\xc3\x02\x20Output\x20only.\x20The\x20current\ + \x20instance\x20state.\x20For\n\x20[CreateInstance][google.spanner.admin\ + .instance.v1.InstanceAdmin.CreateInstance],\x20the\x20state\x20must\x20b\ + e\n\x20either\x20omitted\x20or\x20set\x20to\x20`CREATING`.\x20For\n\x20[\ + UpdateInstance][google.spanner.admin.instance.v1.InstanceAdmin.UpdateIns\ + tance],\x20the\x20state\x20must\x20be\n\x20either\x20omitted\x20or\x20se\ + t\x20to\x20`READY`.\n\n\x0f\n\x05\x04\x01\x02\x04\x04\x12\x06\x9c\x02\ + \x02\x95\x02\x17\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\x9c\x02\x02\x07\n\ + \r\n\x05\x04\x01\x02\x04\x01\x12\x04\x9c\x02\x08\r\n\r\n\x05\x04\x01\x02\ + \x04\x03\x12\x04\x9c\x02\x10\x11\n\xe3\t\n\x04\x04\x01\x02\x05\x12\x04\ + \xb3\x02\x02!\x1a\xd4\t\x20Cloud\x20Labels\x20are\x20a\x20flexible\x20an\ + d\x20lightweight\x20mechanism\x20for\x20organizing\x20cloud\n\x20resourc\ + es\x20into\x20groups\x20that\x20reflect\x20a\x20customer's\x20organizati\ + onal\x20needs\x20and\n\x20deployment\x20strategies.\x20Cloud\x20Labels\ + \x20can\x20be\x20used\x20to\x20filter\x20collections\x20of\n\x20resource\ + s.\x20They\x20can\x20be\x20used\x20to\x20control\x20how\x20resource\x20m\ + etrics\x20are\x20aggregated.\n\x20And\x20they\x20can\x20be\x20used\x20as\ + \x20arguments\x20to\x20policy\x20management\x20rules\x20(e.g.\x20route,\ + \n\x20firewall,\x20load\x20balancing,\x20etc.).\n\n\x20\x20*\x20Label\ + \x20keys\x20must\x20be\x20between\x201\x20and\x2063\x20characters\x20lon\ + g\x20and\x20must\x20conform\x20to\n\x20\x20\x20\x20the\x20following\x20r\ + egular\x20expression:\x20`[a-z]([-a-z0-9]*[a-z0-9])?`.\n\x20\x20*\x20Lab\ + el\x20values\x20must\x20be\x20between\x200\x20and\x2063\x20characters\ + \x20long\x20and\x20must\x20conform\n\x20\x20\x20\x20to\x20the\x20regular\ + \x20expression\x20`([a-z]([-a-z0-9]*[a-z0-9])?)?`.\n\x20\x20*\x20No\x20m\ + ore\x20than\x2064\x20labels\x20can\x20be\x20associated\x20with\x20a\x20g\ + iven\x20resource.\n\n\x20See\x20https://goo.gl/xmQnxf\x20for\x20more\x20\ + information\x20on\x20and\x20examples\x20of\x20labels.\n\n\x20If\x20you\ + \x20plan\x20to\x20use\x20labels\x20in\x20your\x20own\x20code,\x20please\ + \x20note\x20that\x20additional\n\x20characters\x20may\x20be\x20allowed\ + \x20in\x20the\x20future.\x20And\x20so\x20you\x20are\x20advised\x20to\x20\ + use\x20an\n\x20internal\x20label\x20representation,\x20such\x20as\x20JSO\ + N,\x20which\x20doesn't\x20rely\x20upon\n\x20specific\x20characters\x20be\ + ing\x20disallowed.\x20\x20For\x20example,\x20representing\x20labels\n\ + \x20as\x20the\x20string:\x20\x20name\x20+\x20\"_\"\x20+\x20value\x20\x20\ + would\x20prove\x20problematic\x20if\x20we\x20were\x20to\n\x20allow\x20\"\ + _\"\x20in\x20a\x20future\x20release.\n\n\x0f\n\x05\x04\x01\x02\x05\x04\ + \x12\x06\xb3\x02\x02\x9c\x02\x12\n\r\n\x05\x04\x01\x02\x05\x06\x12\x04\ + \xb3\x02\x02\x15\n\r\n\x05\x04\x01\x02\x05\x01\x12\x04\xb3\x02\x16\x1c\n\ + \r\n\x05\x04\x01\x02\x05\x03\x12\x04\xb3\x02\x1f\x20\nz\n\x02\x04\x02\ + \x12\x06\xb7\x02\0\xc5\x02\x01\x1al\x20The\x20request\x20for\x20[ListIns\ + tanceConfigs][google.spanner.admin.instance.v1.InstanceAdmin.ListInstanc\ + eConfigs].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xb7\x02\x08\"\n\xa5\x01\n\ + \x04\x04\x02\x02\0\x12\x04\xbb\x02\x02\x14\x1a\x96\x01\x20Required.\x20T\ + he\x20name\x20of\x20the\x20project\x20for\x20which\x20a\x20list\x20of\ + \x20supported\x20instance\n\x20configurations\x20is\x20requested.\x20Val\ + ues\x20are\x20of\x20the\x20form\n\x20`projects/`.\n\n\x0f\n\x05\ + \x04\x02\x02\0\x04\x12\x06\xbb\x02\x02\xb7\x02$\n\r\n\x05\x04\x02\x02\0\ + \x05\x12\x04\xbb\x02\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xbb\x02\ + \t\x0f\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\xbb\x02\x12\x13\n\x95\x01\n\ + \x04\x04\x02\x02\x01\x12\x04\xbf\x02\x02\x16\x1a\x86\x01\x20Number\x20of\ + \x20instance\x20configurations\x20to\x20be\x20returned\x20in\x20the\x20r\ + esponse.\x20If\x200\x20or\n\x20less,\x20defaults\x20to\x20the\x20server'\ + s\x20maximum\x20allowed\x20page\x20size.\n\n\x0f\n\x05\x04\x02\x02\x01\ + \x04\x12\x06\xbf\x02\x02\xbb\x02\x14\n\r\n\x05\x04\x02\x02\x01\x05\x12\ + \x04\xbf\x02\x02\x07\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xbf\x02\x08\ + \x11\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xbf\x02\x14\x15\n\x8b\x02\n\ + \x04\x04\x02\x02\x02\x12\x04\xc4\x02\x02\x18\x1a\xfc\x01\x20If\x20non-em\ + pty,\x20`page_token`\x20should\x20contain\x20a\n\x20[next_page_token][go\ + ogle.spanner.admin.instance.v1.ListInstanceConfigsResponse.next_page_tok\ + en]\n\x20from\x20a\x20previous\x20[ListInstanceConfigsResponse][google.s\ + panner.admin.instance.v1.ListInstanceConfigsResponse].\n\n\x0f\n\x05\x04\ + \x02\x02\x02\x04\x12\x06\xc4\x02\x02\xbf\x02\x16\n\r\n\x05\x04\x02\x02\ + \x02\x05\x12\x04\xc4\x02\x02\x08\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\ + \xc4\x02\t\x13\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\xc4\x02\x16\x17\n{\ + \n\x02\x04\x03\x12\x06\xc8\x02\0\xd0\x02\x01\x1am\x20The\x20response\x20\ + for\x20[ListInstanceConfigs][google.spanner.admin.instance.v1.InstanceAd\ + min.ListInstanceConfigs].\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xc8\x02\x08#\ + \n>\n\x04\x04\x03\x02\0\x12\x04\xca\x02\x02/\x1a0\x20The\x20list\x20of\ + \x20requested\x20instance\x20configurations.\n\n\r\n\x05\x04\x03\x02\0\ + \x04\x12\x04\xca\x02\x02\n\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\xca\x02\ + \x0b\x19\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\xca\x02\x1a*\n\r\n\x05\x04\ + \x03\x02\0\x03\x12\x04\xca\x02-.\n\xd6\x01\n\x04\x04\x03\x02\x01\x12\x04\ + \xcf\x02\x02\x1d\x1a\xc7\x01\x20`next_page_token`\x20can\x20be\x20sent\ + \x20in\x20a\x20subsequent\n\x20[ListInstanceConfigs][google.spanner.admi\ + n.instance.v1.InstanceAdmin.ListInstanceConfigs]\x20call\x20to\n\x20fetc\ + h\x20more\x20of\x20the\x20matching\x20instance\x20configurations.\n\n\ + \x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\xcf\x02\x02\xca\x02/\n\r\n\x05\ + \x04\x03\x02\x01\x05\x12\x04\xcf\x02\x02\x08\n\r\n\x05\x04\x03\x02\x01\ + \x01\x12\x04\xcf\x02\t\x18\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xcf\x02\ + \x1b\x1c\n~\n\x02\x04\x04\x12\x06\xd4\x02\0\xd8\x02\x01\x1ap\x20The\x20r\ + equest\x20for\n\x20[GetInstanceConfigRequest][google.spanner.admin.insta\ + nce.v1.InstanceAdmin.GetInstanceConfig].\n\n\x0b\n\x03\x04\x04\x01\x12\ + \x04\xd4\x02\x08\x20\n\x93\x01\n\x04\x04\x04\x02\0\x12\x04\xd7\x02\x02\ + \x12\x1a\x84\x01\x20Required.\x20The\x20name\x20of\x20the\x20requested\ + \x20instance\x20configuration.\x20Values\x20are\x20of\n\x20the\x20form\ + \x20`projects//instanceConfigs/`.\n\n\x0f\n\x05\x04\x04\ + \x02\0\x04\x12\x06\xd7\x02\x02\xd4\x02\"\n\r\n\x05\x04\x04\x02\0\x05\x12\ + \x04\xd7\x02\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xd7\x02\t\r\n\r\ + \n\x05\x04\x04\x02\0\x03\x12\x04\xd7\x02\x10\x11\nj\n\x02\x04\x05\x12\ + \x06\xdb\x02\0\xdf\x02\x01\x1a\\\x20The\x20request\x20for\x20[GetInstanc\ + e][google.spanner.admin.instance.v1.InstanceAdmin.GetInstance].\n\n\x0b\ + \n\x03\x04\x05\x01\x12\x04\xdb\x02\x08\x1a\n\x80\x01\n\x04\x04\x05\x02\0\ + \x12\x04\xde\x02\x02\x12\x1ar\x20Required.\x20The\x20name\x20of\x20the\ + \x20requested\x20instance.\x20Values\x20are\x20of\x20the\x20form\n\x20`p\ + rojects//instances/`.\n\n\x0f\n\x05\x04\x05\x02\0\x04\ + \x12\x06\xde\x02\x02\xdb\x02\x1c\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xde\ + \x02\x02\x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\xde\x02\t\r\n\r\n\x05\ + \x04\x05\x02\0\x03\x12\x04\xde\x02\x10\x11\np\n\x02\x04\x06\x12\x06\xe2\ + \x02\0\xef\x02\x01\x1ab\x20The\x20request\x20for\x20[CreateInstance][goo\ + gle.spanner.admin.instance.v1.InstanceAdmin.CreateInstance].\n\n\x0b\n\ + \x03\x04\x06\x01\x12\x04\xe2\x02\x08\x1d\n\x80\x01\n\x04\x04\x06\x02\0\ + \x12\x04\xe5\x02\x02\x14\x1ar\x20Required.\x20The\x20name\x20of\x20the\ + \x20project\x20in\x20which\x20to\x20create\x20the\x20instance.\x20Values\ + \n\x20are\x20of\x20the\x20form\x20`projects/`.\n\n\x0f\n\x05\ + \x04\x06\x02\0\x04\x12\x06\xe5\x02\x02\xe2\x02\x1f\n\r\n\x05\x04\x06\x02\ + \0\x05\x12\x04\xe5\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xe5\ + \x02\t\x0f\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xe5\x02\x12\x13\n\xae\x01\ + \n\x04\x04\x06\x02\x01\x12\x04\xea\x02\x02\x19\x1a\x9f\x01\x20Required.\ + \x20The\x20ID\x20of\x20the\x20instance\x20to\x20create.\x20\x20Valid\x20\ + identifiers\x20are\x20of\x20the\n\x20form\x20`[a-z][-a-z0-9]*[a-z0-9]`\ + \x20and\x20must\x20be\x20between\x206\x20and\x2030\x20characters\x20in\n\ + \x20length.\n\n\x0f\n\x05\x04\x06\x02\x01\x04\x12\x06\xea\x02\x02\xe5\ + \x02\x14\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xea\x02\x02\x08\n\r\n\x05\ + \x04\x06\x02\x01\x01\x12\x04\xea\x02\t\x14\n\r\n\x05\x04\x06\x02\x01\x03\ + \x12\x04\xea\x02\x17\x18\n\x89\x01\n\x04\x04\x06\x02\x02\x12\x04\xee\x02\ + \x02\x18\x1a{\x20Required.\x20The\x20instance\x20to\x20create.\x20\x20Th\ + e\x20name\x20may\x20be\x20omitted,\x20but\x20if\n\x20specified\x20must\ + \x20be\x20`/instances/`.\n\n\x0f\n\x05\x04\x06\x02\ + \x02\x04\x12\x06\xee\x02\x02\xea\x02\x19\n\r\n\x05\x04\x06\x02\x02\x06\ + \x12\x04\xee\x02\x02\n\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\xee\x02\x0b\ + \x13\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\xee\x02\x16\x17\nn\n\x02\x04\ + \x07\x12\x06\xf2\x02\0\x94\x03\x01\x1a`\x20The\x20request\x20for\x20[Lis\ + tInstances][google.spanner.admin.instance.v1.InstanceAdmin.ListInstances\ + ].\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xf2\x02\x08\x1c\n\x8b\x01\n\x04\x04\ + \x07\x02\0\x12\x04\xf5\x02\x02\x14\x1a}\x20Required.\x20The\x20name\x20o\ + f\x20the\x20project\x20for\x20which\x20a\x20list\x20of\x20instances\x20i\ + s\n\x20requested.\x20Values\x20are\x20of\x20the\x20form\x20`projects/`.\n\n\x0f\n\x05\x04\x07\x02\0\x04\x12\x06\xf5\x02\x02\xf2\x02\x1e\ + \n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xf5\x02\x02\x08\n\r\n\x05\x04\x07\ + \x02\0\x01\x12\x04\xf5\x02\t\x0f\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xf5\ + \x02\x12\x13\n\x86\x01\n\x04\x04\x07\x02\x01\x12\x04\xf9\x02\x02\x16\x1a\ + x\x20Number\x20of\x20instances\x20to\x20be\x20returned\x20in\x20the\x20r\ + esponse.\x20If\x200\x20or\x20less,\x20defaults\n\x20to\x20the\x20server'\ + s\x20maximum\x20allowed\x20page\x20size.\n\n\x0f\n\x05\x04\x07\x02\x01\ + \x04\x12\x06\xf9\x02\x02\xf5\x02\x14\n\r\n\x05\x04\x07\x02\x01\x05\x12\ + \x04\xf9\x02\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\xf9\x02\x08\ + \x11\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\xf9\x02\x14\x15\n\xf9\x01\n\ + \x04\x04\x07\x02\x02\x12\x04\xfe\x02\x02\x18\x1a\xea\x01\x20If\x20non-em\ + pty,\x20`page_token`\x20should\x20contain\x20a\n\x20[next_page_token][go\ + ogle.spanner.admin.instance.v1.ListInstancesResponse.next_page_token]\ + \x20from\x20a\n\x20previous\x20[ListInstancesResponse][google.spanner.ad\ + min.instance.v1.ListInstancesResponse].\n\n\x0f\n\x05\x04\x07\x02\x02\ + \x04\x12\x06\xfe\x02\x02\xf9\x02\x16\n\r\n\x05\x04\x07\x02\x02\x05\x12\ + \x04\xfe\x02\x02\x08\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\xfe\x02\t\x13\ + \n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\xfe\x02\x16\x17\n\xdd\x06\n\x04\ + \x04\x07\x02\x03\x12\x04\x93\x03\x02\x14\x1a\xce\x06\x20An\x20expression\ + \x20for\x20filtering\x20the\x20results\x20of\x20the\x20request.\x20Filte\ + r\x20rules\x20are\n\x20case\x20insensitive.\x20The\x20fields\x20eligible\ + \x20for\x20filtering\x20are:\n\n\x20\x20\x20*\x20`name`\n\x20\x20\x20*\ + \x20`display_name`\n\x20\x20\x20*\x20`labels.key`\x20where\x20key\x20is\ + \x20the\x20name\x20of\x20a\x20label\n\n\x20Some\x20examples\x20of\x20usi\ + ng\x20filters\x20are:\n\n\x20\x20\x20*\x20`name:*`\x20-->\x20The\x20inst\ + ance\x20has\x20a\x20name.\n\x20\x20\x20*\x20`name:Howl`\x20-->\x20The\ + \x20instance's\x20name\x20contains\x20the\x20string\x20\"howl\".\n\x20\ + \x20\x20*\x20`name:HOWL`\x20-->\x20Equivalent\x20to\x20above.\n\x20\x20\ + \x20*\x20`NAME:howl`\x20-->\x20Equivalent\x20to\x20above.\n\x20\x20\x20*\ + \x20`labels.env:*`\x20-->\x20The\x20instance\x20has\x20the\x20label\x20\ + \"env\".\n\x20\x20\x20*\x20`labels.env:dev`\x20-->\x20The\x20instance\ + \x20has\x20the\x20label\x20\"env\"\x20and\x20the\x20value\x20of\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20the\x20label\x20contains\x20the\x20string\x20\"dev\"\ + .\n\x20\x20\x20*\x20`name:howl\x20labels.env:dev`\x20-->\x20The\x20insta\ + nce's\x20name\x20contains\x20\"howl\"\x20and\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20it\x20has\x20the\x20label\x20\"e\ + nv\"\x20with\x20its\x20value\n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20containing\x20\"dev\".\n\n\x0f\n\x05\x04\x07\x02\ + \x03\x04\x12\x06\x93\x03\x02\xfe\x02\x18\n\r\n\x05\x04\x07\x02\x03\x05\ + \x12\x04\x93\x03\x02\x08\n\r\n\x05\x04\x07\x02\x03\x01\x12\x04\x93\x03\t\ + \x0f\n\r\n\x05\x04\x07\x02\x03\x03\x12\x04\x93\x03\x12\x13\no\n\x02\x04\ + \x08\x12\x06\x97\x03\0\x9f\x03\x01\x1aa\x20The\x20response\x20for\x20[Li\ + stInstances][google.spanner.admin.instance.v1.InstanceAdmin.ListInstance\ + s].\n\n\x0b\n\x03\x04\x08\x01\x12\x04\x97\x03\x08\x1d\n0\n\x04\x04\x08\ + \x02\0\x12\x04\x99\x03\x02\"\x1a\"\x20The\x20list\x20of\x20requested\x20\ + instances.\n\n\r\n\x05\x04\x08\x02\0\x04\x12\x04\x99\x03\x02\n\n\r\n\x05\ + \x04\x08\x02\0\x06\x12\x04\x99\x03\x0b\x13\n\r\n\x05\x04\x08\x02\0\x01\ + \x12\x04\x99\x03\x14\x1d\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x99\x03\x20\ + !\n\xbc\x01\n\x04\x04\x08\x02\x01\x12\x04\x9e\x03\x02\x1d\x1a\xad\x01\ + \x20`next_page_token`\x20can\x20be\x20sent\x20in\x20a\x20subsequent\n\ + \x20[ListInstances][google.spanner.admin.instance.v1.InstanceAdmin.ListI\ + nstances]\x20call\x20to\x20fetch\x20more\n\x20of\x20the\x20matching\x20i\ + nstances.\n\n\x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\x9e\x03\x02\x99\x03\ + \"\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\x9e\x03\x02\x08\n\r\n\x05\x04\ + \x08\x02\x01\x01\x12\x04\x9e\x03\t\x18\n\r\n\x05\x04\x08\x02\x01\x03\x12\ + \x04\x9e\x03\x1b\x1c\np\n\x02\x04\t\x12\x06\xa2\x03\0\xac\x03\x01\x1ab\ + \x20The\x20request\x20for\x20[UpdateInstance][google.spanner.admin.insta\ + nce.v1.InstanceAdmin.UpdateInstance].\n\n\x0b\n\x03\x04\t\x01\x12\x04\ + \xa2\x03\x08\x1d\n\xdd\x01\n\x04\x04\t\x02\0\x12\x04\xa5\x03\x02\x18\x1a\ + \xce\x01\x20Required.\x20The\x20instance\x20to\x20update,\x20which\x20mu\ + st\x20always\x20include\x20the\x20instance\n\x20name.\x20\x20Otherwise,\ + \x20only\x20fields\x20mentioned\x20in\x20[][google.spanner.admin.instanc\ + e.v1.UpdateInstanceRequest.field_mask]\x20need\x20be\x20included.\n\n\ + \x0f\n\x05\x04\t\x02\0\x04\x12\x06\xa5\x03\x02\xa2\x03\x1f\n\r\n\x05\x04\ + \t\x02\0\x06\x12\x04\xa5\x03\x02\n\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xa5\ + \x03\x0b\x13\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xa5\x03\x16\x17\n\xd7\x02\ + \n\x04\x04\t\x02\x01\x12\x04\xab\x03\x02+\x1a\xc8\x02\x20Required.\x20A\ + \x20mask\x20specifying\x20which\x20fields\x20in\x20[][google.spanner.adm\ + in.instance.v1.UpdateInstanceRequest.instance]\x20should\x20be\x20update\ + d.\n\x20The\x20field\x20mask\x20must\x20always\x20be\x20specified;\x20th\ + is\x20prevents\x20any\x20future\x20fields\x20in\n\x20[][google.spanner.a\ + dmin.instance.v1.Instance]\x20from\x20being\x20erased\x20accidentally\ + \x20by\x20clients\x20that\x20do\x20not\x20know\n\x20about\x20them.\n\n\ + \x0f\n\x05\x04\t\x02\x01\x04\x12\x06\xab\x03\x02\xa5\x03\x18\n\r\n\x05\ + \x04\t\x02\x01\x06\x12\x04\xab\x03\x02\x1b\n\r\n\x05\x04\t\x02\x01\x01\ + \x12\x04\xab\x03\x1c&\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xab\x03)*\np\n\ + \x02\x04\n\x12\x06\xaf\x03\0\xb3\x03\x01\x1ab\x20The\x20request\x20for\ + \x20[DeleteInstance][google.spanner.admin.instance.v1.InstanceAdmin.Dele\ + teInstance].\n\n\x0b\n\x03\x04\n\x01\x12\x04\xaf\x03\x08\x1d\n\x83\x01\n\ + \x04\x04\n\x02\0\x12\x04\xb2\x03\x02\x12\x1au\x20Required.\x20The\x20nam\ + e\x20of\x20the\x20instance\x20to\x20be\x20deleted.\x20Values\x20are\x20o\ + f\x20the\x20form\n\x20`projects//instances/`\n\n\x0f\ + \n\x05\x04\n\x02\0\x04\x12\x06\xb2\x03\x02\xaf\x03\x1f\n\r\n\x05\x04\n\ + \x02\0\x05\x12\x04\xb2\x03\x02\x08\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xb2\ + \x03\t\r\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xb2\x03\x10\x11\n\x8d\x01\n\ + \x02\x04\x0b\x12\x06\xb7\x03\0\xc7\x03\x01\x1a\x7f\x20Metadata\x20type\ + \x20for\x20the\x20operation\x20returned\x20by\n\x20[CreateInstance][goog\ + le.spanner.admin.instance.v1.InstanceAdmin.CreateInstance].\n\n\x0b\n\ + \x03\x04\x0b\x01\x12\x04\xb7\x03\x08\x1e\n+\n\x04\x04\x0b\x02\0\x12\x04\ + \xb9\x03\x02\x18\x1a\x1d\x20The\x20instance\x20being\x20created.\n\n\x0f\ + \n\x05\x04\x0b\x02\0\x04\x12\x06\xb9\x03\x02\xb7\x03\x20\n\r\n\x05\x04\ + \x0b\x02\0\x06\x12\x04\xb9\x03\x02\n\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\ + \xb9\x03\x0b\x13\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xb9\x03\x16\x17\n\ + \x8d\x01\n\x04\x04\x0b\x02\x01\x12\x04\xbe\x03\x02+\x1a\x7f\x20The\x20ti\ + me\x20at\x20which\x20the\n\x20[CreateInstance][google.spanner.admin.inst\ + ance.v1.InstanceAdmin.CreateInstance]\x20request\x20was\n\x20received.\n\ + \n\x0f\n\x05\x04\x0b\x02\x01\x04\x12\x06\xbe\x03\x02\xb9\x03\x18\n\r\n\ + \x05\x04\x0b\x02\x01\x06\x12\x04\xbe\x03\x02\x1b\n\r\n\x05\x04\x0b\x02\ + \x01\x01\x12\x04\xbe\x03\x1c&\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\xbe\ + \x03)*\n\xbd\x01\n\x04\x04\x0b\x02\x02\x12\x04\xc3\x03\x02,\x1a\xae\x01\ + \x20The\x20time\x20at\x20which\x20this\x20operation\x20was\x20cancelled.\ + \x20If\x20set,\x20this\x20operation\x20is\n\x20in\x20the\x20process\x20o\ + f\x20undoing\x20itself\x20(which\x20is\x20guaranteed\x20to\x20succeed)\ + \x20and\n\x20cannot\x20be\x20cancelled\x20again.\n\n\x0f\n\x05\x04\x0b\ + \x02\x02\x04\x12\x06\xc3\x03\x02\xbe\x03+\n\r\n\x05\x04\x0b\x02\x02\x06\ + \x12\x04\xc3\x03\x02\x1b\n\r\n\x05\x04\x0b\x02\x02\x01\x12\x04\xc3\x03\ + \x1c'\n\r\n\x05\x04\x0b\x02\x02\x03\x12\x04\xc3\x03*+\nV\n\x04\x04\x0b\ + \x02\x03\x12\x04\xc6\x03\x02)\x1aH\x20The\x20time\x20at\x20which\x20this\ + \x20operation\x20failed\x20or\x20was\x20completed\x20successfully.\n\n\ + \x0f\n\x05\x04\x0b\x02\x03\x04\x12\x06\xc6\x03\x02\xc3\x03,\n\r\n\x05\ + \x04\x0b\x02\x03\x06\x12\x04\xc6\x03\x02\x1b\n\r\n\x05\x04\x0b\x02\x03\ + \x01\x12\x04\xc6\x03\x1c$\n\r\n\x05\x04\x0b\x02\x03\x03\x12\x04\xc6\x03'\ + (\n\x8d\x01\n\x02\x04\x0c\x12\x06\xcb\x03\0\xda\x03\x01\x1a\x7f\x20Metad\ + ata\x20type\x20for\x20the\x20operation\x20returned\x20by\n\x20[UpdateIns\ + tance][google.spanner.admin.instance.v1.InstanceAdmin.UpdateInstance].\n\ + \n\x0b\n\x03\x04\x0c\x01\x12\x04\xcb\x03\x08\x1e\n4\n\x04\x04\x0c\x02\0\ + \x12\x04\xcd\x03\x02\x18\x1a&\x20The\x20desired\x20end\x20state\x20of\ + \x20the\x20update.\n\n\x0f\n\x05\x04\x0c\x02\0\x04\x12\x06\xcd\x03\x02\ + \xcb\x03\x20\n\r\n\x05\x04\x0c\x02\0\x06\x12\x04\xcd\x03\x02\n\n\r\n\x05\ + \x04\x0c\x02\0\x01\x12\x04\xcd\x03\x0b\x13\n\r\n\x05\x04\x0c\x02\0\x03\ + \x12\x04\xcd\x03\x16\x17\n\x88\x01\n\x04\x04\x0c\x02\x01\x12\x04\xd1\x03\ + \x02+\x1az\x20The\x20time\x20at\x20which\x20[UpdateInstance][google.span\ + ner.admin.instance.v1.InstanceAdmin.UpdateInstance]\n\x20request\x20was\ + \x20received.\n\n\x0f\n\x05\x04\x0c\x02\x01\x04\x12\x06\xd1\x03\x02\xcd\ + \x03\x18\n\r\n\x05\x04\x0c\x02\x01\x06\x12\x04\xd1\x03\x02\x1b\n\r\n\x05\ + \x04\x0c\x02\x01\x01\x12\x04\xd1\x03\x1c&\n\r\n\x05\x04\x0c\x02\x01\x03\ + \x12\x04\xd1\x03)*\n\xbd\x01\n\x04\x04\x0c\x02\x02\x12\x04\xd6\x03\x02,\ + \x1a\xae\x01\x20The\x20time\x20at\x20which\x20this\x20operation\x20was\ + \x20cancelled.\x20If\x20set,\x20this\x20operation\x20is\n\x20in\x20the\ + \x20process\x20of\x20undoing\x20itself\x20(which\x20is\x20guaranteed\x20\ + to\x20succeed)\x20and\n\x20cannot\x20be\x20cancelled\x20again.\n\n\x0f\n\ + \x05\x04\x0c\x02\x02\x04\x12\x06\xd6\x03\x02\xd1\x03+\n\r\n\x05\x04\x0c\ + \x02\x02\x06\x12\x04\xd6\x03\x02\x1b\n\r\n\x05\x04\x0c\x02\x02\x01\x12\ + \x04\xd6\x03\x1c'\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xd6\x03*+\nV\n\ + \x04\x04\x0c\x02\x03\x12\x04\xd9\x03\x02)\x1aH\x20The\x20time\x20at\x20w\ + hich\x20this\x20operation\x20failed\x20or\x20was\x20completed\x20success\ + fully.\n\n\x0f\n\x05\x04\x0c\x02\x03\x04\x12\x06\xd9\x03\x02\xd6\x03,\n\ + \r\n\x05\x04\x0c\x02\x03\x06\x12\x04\xd9\x03\x02\x1b\n\r\n\x05\x04\x0c\ + \x02\x03\x01\x12\x04\xd9\x03\x1c$\n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\ + \xd9\x03'(b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin_grpc.rs new file mode 100644 index 00000000..09e0789e --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/instance/v1/spanner_instance_admin_grpc.rs @@ -0,0 +1,323 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_INSTANCE_ADMIN_LIST_INSTANCE_CONFIGS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstanceConfigs", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_GET_INSTANCE_CONFIG: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstanceConfig", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_LIST_INSTANCES: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstances", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_GET_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_CREATE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/CreateInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_UPDATE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/UpdateInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_DELETE_INSTANCE: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/DeleteInstance", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_SET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/SetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_GET_IAM_POLICY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/GetIamPolicy", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.admin.instance.v1.InstanceAdmin/TestIamPermissions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct InstanceAdminClient { + client: ::grpcio::Client, +} + +impl InstanceAdminClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + InstanceAdminClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn list_instance_configs_opt(&self, req: &super::spanner_instance_admin::ListInstanceConfigsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_LIST_INSTANCE_CONFIGS, req, opt) + } + + pub fn list_instance_configs(&self, req: &super::spanner_instance_admin::ListInstanceConfigsRequest) -> ::grpcio::Result { + self.list_instance_configs_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_instance_configs_async_opt(&self, req: &super::spanner_instance_admin::ListInstanceConfigsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_LIST_INSTANCE_CONFIGS, req, opt) + } + + pub fn list_instance_configs_async(&self, req: &super::spanner_instance_admin::ListInstanceConfigsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_instance_configs_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_config_opt(&self, req: &super::spanner_instance_admin::GetInstanceConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_GET_INSTANCE_CONFIG, req, opt) + } + + pub fn get_instance_config(&self, req: &super::spanner_instance_admin::GetInstanceConfigRequest) -> ::grpcio::Result { + self.get_instance_config_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_config_async_opt(&self, req: &super::spanner_instance_admin::GetInstanceConfigRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_GET_INSTANCE_CONFIG, req, opt) + } + + pub fn get_instance_config_async(&self, req: &super::spanner_instance_admin::GetInstanceConfigRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_instance_config_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_instances_opt(&self, req: &super::spanner_instance_admin::ListInstancesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_LIST_INSTANCES, req, opt) + } + + pub fn list_instances(&self, req: &super::spanner_instance_admin::ListInstancesRequest) -> ::grpcio::Result { + self.list_instances_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_instances_async_opt(&self, req: &super::spanner_instance_admin::ListInstancesRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_LIST_INSTANCES, req, opt) + } + + pub fn list_instances_async(&self, req: &super::spanner_instance_admin::ListInstancesRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_instances_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_opt(&self, req: &super::spanner_instance_admin::GetInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_GET_INSTANCE, req, opt) + } + + pub fn get_instance(&self, req: &super::spanner_instance_admin::GetInstanceRequest) -> ::grpcio::Result { + self.get_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_instance_async_opt(&self, req: &super::spanner_instance_admin::GetInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_GET_INSTANCE, req, opt) + } + + pub fn get_instance_async(&self, req: &super::spanner_instance_admin::GetInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_instance_opt(&self, req: &super::spanner_instance_admin::CreateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_CREATE_INSTANCE, req, opt) + } + + pub fn create_instance(&self, req: &super::spanner_instance_admin::CreateInstanceRequest) -> ::grpcio::Result { + self.create_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_instance_async_opt(&self, req: &super::spanner_instance_admin::CreateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_CREATE_INSTANCE, req, opt) + } + + pub fn create_instance_async(&self, req: &super::spanner_instance_admin::CreateInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_instance_opt(&self, req: &super::spanner_instance_admin::UpdateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_UPDATE_INSTANCE, req, opt) + } + + pub fn update_instance(&self, req: &super::spanner_instance_admin::UpdateInstanceRequest) -> ::grpcio::Result { + self.update_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn update_instance_async_opt(&self, req: &super::spanner_instance_admin::UpdateInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_UPDATE_INSTANCE, req, opt) + } + + pub fn update_instance_async(&self, req: &super::spanner_instance_admin::UpdateInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.update_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_instance_opt(&self, req: &super::spanner_instance_admin::DeleteInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_DELETE_INSTANCE, req, opt) + } + + pub fn delete_instance(&self, req: &super::spanner_instance_admin::DeleteInstanceRequest) -> ::grpcio::Result { + self.delete_instance_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_instance_async_opt(&self, req: &super::spanner_instance_admin::DeleteInstanceRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_DELETE_INSTANCE, req, opt) + } + + pub fn delete_instance_async(&self, req: &super::spanner_instance_admin::DeleteInstanceRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_instance_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result { + self.set_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn set_iam_policy_async_opt(&self, req: &super::iam_policy::SetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_SET_IAM_POLICY, req, opt) + } + + pub fn set_iam_policy_async(&self, req: &super::iam_policy::SetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.set_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result { + self.get_iam_policy_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_iam_policy_async_opt(&self, req: &super::iam_policy::GetIamPolicyRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_GET_IAM_POLICY, req, opt) + } + + pub fn get_iam_policy_async(&self, req: &super::iam_policy::GetIamPolicyRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_iam_policy_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result { + self.test_iam_permissions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn test_iam_permissions_async_opt(&self, req: &super::iam_policy::TestIamPermissionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, req, opt) + } + + pub fn test_iam_permissions_async(&self, req: &super::iam_policy::TestIamPermissionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.test_iam_permissions_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait InstanceAdmin { + fn list_instance_configs(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::ListInstanceConfigsRequest, sink: ::grpcio::UnarySink); + fn get_instance_config(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::GetInstanceConfigRequest, sink: ::grpcio::UnarySink); + fn list_instances(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::ListInstancesRequest, sink: ::grpcio::UnarySink); + fn get_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::GetInstanceRequest, sink: ::grpcio::UnarySink); + fn create_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::CreateInstanceRequest, sink: ::grpcio::UnarySink); + fn update_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::UpdateInstanceRequest, sink: ::grpcio::UnarySink); + fn delete_instance(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner_instance_admin::DeleteInstanceRequest, sink: ::grpcio::UnarySink); + fn set_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::SetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn get_iam_policy(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::GetIamPolicyRequest, sink: ::grpcio::UnarySink); + fn test_iam_permissions(&mut self, ctx: ::grpcio::RpcContext, req: super::iam_policy::TestIamPermissionsRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_instance_admin(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_LIST_INSTANCE_CONFIGS, move |ctx, req, resp| { + instance.list_instance_configs(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_GET_INSTANCE_CONFIG, move |ctx, req, resp| { + instance.get_instance_config(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_LIST_INSTANCES, move |ctx, req, resp| { + instance.list_instances(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_GET_INSTANCE, move |ctx, req, resp| { + instance.get_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_CREATE_INSTANCE, move |ctx, req, resp| { + instance.create_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_UPDATE_INSTANCE, move |ctx, req, resp| { + instance.update_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_DELETE_INSTANCE, move |ctx, req, resp| { + instance.delete_instance(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_SET_IAM_POLICY, move |ctx, req, resp| { + instance.set_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_GET_IAM_POLICY, move |ctx, req, resp| { + instance.get_iam_policy(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_INSTANCE_ADMIN_TEST_IAM_PERMISSIONS, move |ctx, req, resp| { + instance.test_iam_permissions(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/mod.rs new file mode 100644 index 00000000..8d7f542a --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/admin/mod.rs @@ -0,0 +1,2 @@ +pub mod database; +pub mod instance; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/mod.rs new file mode 100644 index 00000000..fa0c4fbd --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/mod.rs @@ -0,0 +1,2 @@ +pub mod admin; +pub mod v1; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/keys.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/keys.rs new file mode 100644 index 00000000..bb3550c0 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/keys.rs @@ -0,0 +1,920 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/keys.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct KeyRange { + // message oneof groups + pub start_key_type: ::std::option::Option, + pub end_key_type: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a KeyRange { + fn default() -> &'a KeyRange { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyRange_oneof_start_key_type { + start_closed(::protobuf::well_known_types::ListValue), + start_open(::protobuf::well_known_types::ListValue), +} + +#[derive(Clone,PartialEq,Debug)] +pub enum KeyRange_oneof_end_key_type { + end_closed(::protobuf::well_known_types::ListValue), + end_open(::protobuf::well_known_types::ListValue), +} + +impl KeyRange { + pub fn new() -> KeyRange { + ::std::default::Default::default() + } + + // .google.protobuf.ListValue start_closed = 1; + + + pub fn get_start_closed(&self) -> &::protobuf::well_known_types::ListValue { + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(ref v)) => v, + _ => ::protobuf::well_known_types::ListValue::default_instance(), + } + } + pub fn clear_start_closed(&mut self) { + self.start_key_type = ::std::option::Option::None; + } + + pub fn has_start_closed(&self) -> bool { + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_closed(&mut self, v: ::protobuf::well_known_types::ListValue) { + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_closed(&mut self) -> &mut ::protobuf::well_known_types::ListValue { + if let ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(_)) = self.start_key_type { + } else { + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(::protobuf::well_known_types::ListValue::new())); + } + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_closed(&mut self) -> ::protobuf::well_known_types::ListValue { + if self.has_start_closed() { + match self.start_key_type.take() { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::ListValue::new() + } + } + + // .google.protobuf.ListValue start_open = 2; + + + pub fn get_start_open(&self) -> &::protobuf::well_known_types::ListValue { + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(ref v)) => v, + _ => ::protobuf::well_known_types::ListValue::default_instance(), + } + } + pub fn clear_start_open(&mut self) { + self.start_key_type = ::std::option::Option::None; + } + + pub fn has_start_open(&self) -> bool { + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_start_open(&mut self, v: ::protobuf::well_known_types::ListValue) { + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_start_open(&mut self) -> &mut ::protobuf::well_known_types::ListValue { + if let ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(_)) = self.start_key_type { + } else { + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(::protobuf::well_known_types::ListValue::new())); + } + match self.start_key_type { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_start_open(&mut self) -> ::protobuf::well_known_types::ListValue { + if self.has_start_open() { + match self.start_key_type.take() { + ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::ListValue::new() + } + } + + // .google.protobuf.ListValue end_closed = 3; + + + pub fn get_end_closed(&self) -> &::protobuf::well_known_types::ListValue { + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(ref v)) => v, + _ => ::protobuf::well_known_types::ListValue::default_instance(), + } + } + pub fn clear_end_closed(&mut self) { + self.end_key_type = ::std::option::Option::None; + } + + pub fn has_end_closed(&self) -> bool { + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_closed(&mut self, v: ::protobuf::well_known_types::ListValue) { + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_closed(&mut self) -> &mut ::protobuf::well_known_types::ListValue { + if let ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(_)) = self.end_key_type { + } else { + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(::protobuf::well_known_types::ListValue::new())); + } + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_closed(&mut self) -> ::protobuf::well_known_types::ListValue { + if self.has_end_closed() { + match self.end_key_type.take() { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::ListValue::new() + } + } + + // .google.protobuf.ListValue end_open = 4; + + + pub fn get_end_open(&self) -> &::protobuf::well_known_types::ListValue { + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(ref v)) => v, + _ => ::protobuf::well_known_types::ListValue::default_instance(), + } + } + pub fn clear_end_open(&mut self) { + self.end_key_type = ::std::option::Option::None; + } + + pub fn has_end_open(&self) -> bool { + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_end_open(&mut self, v: ::protobuf::well_known_types::ListValue) { + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(v)) + } + + // Mutable pointer to the field. + pub fn mut_end_open(&mut self) -> &mut ::protobuf::well_known_types::ListValue { + if let ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(_)) = self.end_key_type { + } else { + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(::protobuf::well_known_types::ListValue::new())); + } + match self.end_key_type { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_end_open(&mut self) -> ::protobuf::well_known_types::ListValue { + if self.has_end_open() { + match self.end_key_type.take() { + ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::ListValue::new() + } + } +} + +impl ::protobuf::Message for KeyRange { + fn is_initialized(&self) -> bool { + if let Some(KeyRange_oneof_start_key_type::start_closed(ref v)) = self.start_key_type { + if !v.is_initialized() { + return false; + } + } + if let Some(KeyRange_oneof_start_key_type::start_open(ref v)) = self.start_key_type { + if !v.is_initialized() { + return false; + } + } + if let Some(KeyRange_oneof_end_key_type::end_closed(ref v)) = self.end_key_type { + if !v.is_initialized() { + return false; + } + } + if let Some(KeyRange_oneof_end_key_type::end_open(ref v)) = self.end_key_type { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_closed(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.start_key_type = ::std::option::Option::Some(KeyRange_oneof_start_key_type::start_open(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_closed(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.end_key_type = ::std::option::Option::Some(KeyRange_oneof_end_key_type::end_open(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.start_key_type { + match v { + &KeyRange_oneof_start_key_type::start_closed(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &KeyRange_oneof_start_key_type::start_open(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_key_type { + match v { + &KeyRange_oneof_end_key_type::end_closed(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &KeyRange_oneof_end_key_type::end_open(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.start_key_type { + match v { + &KeyRange_oneof_start_key_type::start_closed(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &KeyRange_oneof_start_key_type::start_open(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + if let ::std::option::Option::Some(ref v) = self.end_key_type { + match v { + &KeyRange_oneof_end_key_type::end_closed(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &KeyRange_oneof_end_key_type::end_open(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> KeyRange { + KeyRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::ListValue>( + "start_closed", + KeyRange::has_start_closed, + KeyRange::get_start_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::ListValue>( + "start_open", + KeyRange::has_start_open, + KeyRange::get_start_open, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::ListValue>( + "end_closed", + KeyRange::has_end_closed, + KeyRange::get_end_closed, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::ListValue>( + "end_open", + KeyRange::has_end_open, + KeyRange::get_end_open, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "KeyRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static KeyRange { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const KeyRange, + }; + unsafe { + instance.get(KeyRange::new) + } + } +} + +impl ::protobuf::Clear for KeyRange { + fn clear(&mut self) { + self.start_key_type = ::std::option::Option::None; + self.start_key_type = ::std::option::Option::None; + self.end_key_type = ::std::option::Option::None; + self.end_key_type = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for KeyRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for KeyRange { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct KeySet { + // message fields + pub keys: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>, + pub ranges: ::protobuf::RepeatedField, + pub all: bool, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a KeySet { + fn default() -> &'a KeySet { + ::default_instance() + } +} + +impl KeySet { + pub fn new() -> KeySet { + ::std::default::Default::default() + } + + // repeated .google.protobuf.ListValue keys = 1; + + + pub fn get_keys(&self) -> &[::protobuf::well_known_types::ListValue] { + &self.keys + } + pub fn clear_keys(&mut self) { + self.keys.clear(); + } + + // Param is passed by value, moved + pub fn set_keys(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>) { + self.keys = v; + } + + // Mutable pointer to the field. + pub fn mut_keys(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + &mut self.keys + } + + // Take field + pub fn take_keys(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + ::std::mem::replace(&mut self.keys, ::protobuf::RepeatedField::new()) + } + + // repeated .google.spanner.v1.KeyRange ranges = 2; + + + pub fn get_ranges(&self) -> &[KeyRange] { + &self.ranges + } + pub fn clear_ranges(&mut self) { + self.ranges.clear(); + } + + // Param is passed by value, moved + pub fn set_ranges(&mut self, v: ::protobuf::RepeatedField) { + self.ranges = v; + } + + // Mutable pointer to the field. + pub fn mut_ranges(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.ranges + } + + // Take field + pub fn take_ranges(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.ranges, ::protobuf::RepeatedField::new()) + } + + // bool all = 3; + + + pub fn get_all(&self) -> bool { + self.all + } + pub fn clear_all(&mut self) { + self.all = false; + } + + // Param is passed by value, moved + pub fn set_all(&mut self, v: bool) { + self.all = v; + } +} + +impl ::protobuf::Message for KeySet { + fn is_initialized(&self) -> bool { + for v in &self.keys { + if !v.is_initialized() { + return false; + } + }; + for v in &self.ranges { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.keys)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.ranges)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.all = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.keys { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.ranges { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.all != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.keys { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.ranges { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if self.all != false { + os.write_bool(3, self.all)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> KeySet { + KeySet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::ListValue>>( + "keys", + |m: &KeySet| { &m.keys }, + |m: &mut KeySet| { &mut m.keys }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "ranges", + |m: &KeySet| { &m.ranges }, + |m: &mut KeySet| { &mut m.ranges }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "all", + |m: &KeySet| { &m.all }, + |m: &mut KeySet| { &mut m.all }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "KeySet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static KeySet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const KeySet, + }; + unsafe { + instance.get(KeySet::new) + } + } +} + +impl ::protobuf::Clear for KeySet { + fn clear(&mut self) { + self.keys.clear(); + self.ranges.clear(); + self.all = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for KeySet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for KeySet { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1cgoogle/spanner/v1/keys.proto\x12\x11google.spanner.v1\x1a\x1cgoogl\ + e/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\"\xa0\x02\n\ + \x08KeyRange\x12?\n\x0cstart_closed\x18\x01\x20\x01(\x0b2\x1a.google.pro\ + tobuf.ListValueH\0R\x0bstartClosed\x12;\n\nstart_open\x18\x02\x20\x01(\ + \x0b2\x1a.google.protobuf.ListValueH\0R\tstartOpen\x12;\n\nend_closed\ + \x18\x03\x20\x01(\x0b2\x1a.google.protobuf.ListValueH\x01R\tendClosed\ + \x127\n\x08end_open\x18\x04\x20\x01(\x0b2\x1a.google.protobuf.ListValueH\ + \x01R\x07endOpenB\x10\n\x0estart_key_typeB\x0e\n\x0cend_key_type\"\x7f\n\ + \x06KeySet\x12.\n\x04keys\x18\x01\x20\x03(\x0b2\x1a.google.protobuf.List\ + ValueR\x04keys\x123\n\x06ranges\x18\x02\x20\x03(\x0b2\x1b.google.spanner\ + .v1.KeyRangeR\x06ranges\x12\x10\n\x03all\x18\x03\x20\x01(\x08R\x03allB\ + \x92\x01\n\x15com.google.spanner.v1B\tKeysProtoP\x01Z8google.golang.org/\ + genproto/googleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V\ + 1\xca\x02\x17Google\\Cloud\\Spanner\\V1J\x82,\n\x07\x12\x05\x0e\0\xa2\ + \x01\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x20\ + 2018\x20Google\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apache\x20Licen\ + se,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\ + \x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20\ + License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\ + \x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\ + \n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\ + \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\ + \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\ + \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\ + ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\ + the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\ + tations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\ + \n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0&\n\x08\n\ + \x01\x08\x12\x03\x15\04\n\t\n\x02\x08%\x12\x03\x15\04\n\x08\n\x01\x08\ + \x12\x03\x16\0O\n\t\n\x02\x08\x0b\x12\x03\x16\0O\n\x08\n\x01\x08\x12\x03\ + \x17\0\"\n\t\n\x02\x08\n\x12\x03\x17\0\"\n\x08\n\x01\x08\x12\x03\x18\0*\ + \n\t\n\x02\x08\x08\x12\x03\x18\0*\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\ + \x02\x08\x01\x12\x03\x19\0.\n\x08\n\x01\x08\x12\x03\x1a\04\n\t\n\x02\x08\ + )\x12\x03\x1a\04\n\xb4\x15\n\x02\x04\0\x12\x05t\0\x8a\x01\x01\x1a\xa6\ + \x15\x20KeyRange\x20represents\x20a\x20range\x20of\x20rows\x20in\x20a\ + \x20table\x20or\x20index.\n\n\x20A\x20range\x20has\x20a\x20start\x20key\ + \x20and\x20an\x20end\x20key.\x20These\x20keys\x20can\x20be\x20open\x20or\ + \n\x20closed,\x20indicating\x20if\x20the\x20range\x20includes\x20rows\ + \x20with\x20that\x20key.\n\n\x20Keys\x20are\x20represented\x20by\x20list\ + s,\x20where\x20the\x20ith\x20value\x20in\x20the\x20list\n\x20corresponds\ + \x20to\x20the\x20ith\x20component\x20of\x20the\x20table\x20or\x20index\ + \x20primary\x20key.\n\x20Individual\x20values\x20are\x20encoded\x20as\ + \x20described\x20[here][google.spanner.v1.TypeCode].\n\n\x20For\x20examp\ + le,\x20consider\x20the\x20following\x20table\x20definition:\n\n\x20\x20\ + \x20\x20\x20CREATE\x20TABLE\x20UserEvents\x20(\n\x20\x20\x20\x20\x20\x20\ + \x20UserName\x20STRING(MAX),\n\x20\x20\x20\x20\x20\x20\x20EventDate\x20S\ + TRING(10)\n\x20\x20\x20\x20\x20)\x20PRIMARY\x20KEY(UserName,\x20EventDat\ + e);\n\n\x20The\x20following\x20keys\x20name\x20rows\x20in\x20this\x20tab\ + le:\n\n\x20\x20\x20\x20\x20[\"Bob\",\x20\"2014-09-23\"]\n\x20\x20\x20\ + \x20\x20[\"Alfred\",\x20\"2015-06-12\"]\n\n\x20Since\x20the\x20`UserEven\ + ts`\x20table's\x20`PRIMARY\x20KEY`\x20clause\x20names\x20two\n\x20column\ + s,\x20each\x20`UserEvents`\x20key\x20has\x20two\x20elements;\x20the\x20f\ + irst\x20is\x20the\n\x20`UserName`,\x20and\x20the\x20second\x20is\x20the\ + \x20`EventDate`.\n\n\x20Key\x20ranges\x20with\x20multiple\x20components\ + \x20are\x20interpreted\n\x20lexicographically\x20by\x20component\x20usin\ + g\x20the\x20table\x20or\x20index\x20key's\x20declared\n\x20sort\x20order\ + .\x20For\x20example,\x20the\x20following\x20range\x20returns\x20all\x20e\ + vents\x20for\n\x20user\x20`\"Bob\"`\x20that\x20occurred\x20in\x20the\x20\ + year\x202015:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[\"Bob\",\x20\ + \"2015-01-01\"]\n\x20\x20\x20\x20\x20\"end_closed\":\x20[\"Bob\",\x20\"2\ + 015-12-31\"]\n\n\x20Start\x20and\x20end\x20keys\x20can\x20omit\x20traili\ + ng\x20key\x20components.\x20This\x20affects\x20the\n\x20inclusion\x20and\ + \x20exclusion\x20of\x20rows\x20that\x20exactly\x20match\x20the\x20provid\ + ed\x20key\n\x20components:\x20if\x20the\x20key\x20is\x20closed,\x20then\ + \x20rows\x20that\x20exactly\x20match\x20the\n\x20provided\x20components\ + \x20are\x20included;\x20if\x20the\x20key\x20is\x20open,\x20then\x20rows\ + \n\x20that\x20exactly\x20match\x20are\x20not\x20included.\n\n\x20For\x20\ + example,\x20the\x20following\x20range\x20includes\x20all\x20events\x20fo\ + r\x20`\"Bob\"`\x20that\n\x20occurred\x20during\x20and\x20after\x20the\ + \x20year\x202000:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[\"Bob\",\ + \x20\"2000-01-01\"]\n\x20\x20\x20\x20\x20\"end_closed\":\x20[\"Bob\"]\n\ + \n\x20The\x20next\x20example\x20retrieves\x20all\x20events\x20for\x20`\"\ + Bob\"`:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[\"Bob\"]\n\x20\x20\ + \x20\x20\x20\"end_closed\":\x20[\"Bob\"]\n\n\x20To\x20retrieve\x20events\ + \x20before\x20the\x20year\x202000:\n\n\x20\x20\x20\x20\x20\"start_closed\ + \":\x20[\"Bob\"]\n\x20\x20\x20\x20\x20\"end_open\":\x20[\"Bob\",\x20\"20\ + 00-01-01\"]\n\n\x20The\x20following\x20range\x20includes\x20all\x20rows\ + \x20in\x20the\x20table:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[]\n\ + \x20\x20\x20\x20\x20\"end_closed\":\x20[]\n\n\x20This\x20range\x20return\ + s\x20all\x20users\x20whose\x20`UserName`\x20begins\x20with\x20any\n\x20c\ + haracter\x20from\x20A\x20to\x20C:\n\n\x20\x20\x20\x20\x20\"start_closed\ + \":\x20[\"A\"]\n\x20\x20\x20\x20\x20\"end_open\":\x20[\"D\"]\n\n\x20This\ + \x20range\x20returns\x20all\x20users\x20whose\x20`UserName`\x20begins\ + \x20with\x20B:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[\"B\"]\n\x20\ + \x20\x20\x20\x20\"end_open\":\x20[\"C\"]\n\n\x20Key\x20ranges\x20honor\ + \x20column\x20sort\x20order.\x20For\x20example,\x20suppose\x20a\x20table\ + \x20is\n\x20defined\x20as\x20follows:\n\n\x20\x20\x20\x20\x20CREATE\x20T\ + ABLE\x20DescendingSortedTable\x20{\n\x20\x20\x20\x20\x20\x20\x20Key\x20I\ + NT64,\n\x20\x20\x20\x20\x20\x20\x20...\n\x20\x20\x20\x20\x20)\x20PRIMARY\ + \x20KEY(Key\x20DESC);\n\n\x20The\x20following\x20range\x20retrieves\x20a\ + ll\x20rows\x20with\x20key\x20values\x20between\x201\n\x20and\x20100\x20i\ + nclusive:\n\n\x20\x20\x20\x20\x20\"start_closed\":\x20[\"100\"]\n\x20\ + \x20\x20\x20\x20\"end_closed\":\x20[\"1\"]\n\n\x20Note\x20that\x20100\ + \x20is\x20passed\x20as\x20the\x20start,\x20and\x201\x20is\x20passed\x20a\ + s\x20the\x20end,\n\x20because\x20`Key`\x20is\x20a\x20descending\x20colum\ + n\x20in\x20the\x20schema.\n\n\n\n\x03\x04\0\x01\x12\x03t\x08\x10\nP\n\ + \x04\x04\0\x08\0\x12\x04v\x02~\x03\x1aB\x20The\x20start\x20key\x20must\ + \x20be\x20provided.\x20It\x20can\x20be\x20either\x20closed\x20or\x20open\ + .\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03v\x08\x16\n\x93\x01\n\x04\x04\0\ + \x02\0\x12\x03y\x04/\x1a\x85\x01\x20If\x20the\x20start\x20is\x20closed,\ + \x20then\x20the\x20range\x20includes\x20all\x20rows\x20whose\n\x20first\ + \x20`len(start_closed)`\x20key\x20columns\x20exactly\x20match\x20`start_\ + closed`.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03y\x04\x1d\n\x0c\n\x05\x04\ + \0\x02\0\x01\x12\x03y\x1e*\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03y-.\n\x88\ + \x01\n\x04\x04\0\x02\x01\x12\x03}\x04-\x1a{\x20If\x20the\x20start\x20is\ + \x20open,\x20then\x20the\x20range\x20excludes\x20rows\x20whose\x20first\ + \n\x20`len(start_open)`\x20key\x20columns\x20exactly\x20match\x20`start_\ + open`.\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03}\x04\x1d\n\x0c\n\x05\x04\ + \0\x02\x01\x01\x12\x03}\x1e(\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03}+,\nP\ + \n\x04\x04\0\x08\x01\x12\x06\x81\x01\x02\x89\x01\x03\x1a@\x20The\x20end\ + \x20key\x20must\x20be\x20provided.\x20It\x20can\x20be\x20either\x20close\ + d\x20or\x20open.\n\n\r\n\x05\x04\0\x08\x01\x01\x12\x04\x81\x01\x08\x14\n\ + \x8d\x01\n\x04\x04\0\x02\x02\x12\x04\x84\x01\x04-\x1a\x7f\x20If\x20the\ + \x20end\x20is\x20closed,\x20then\x20the\x20range\x20includes\x20all\x20r\ + ows\x20whose\n\x20first\x20`len(end_closed)`\x20key\x20columns\x20exactl\ + y\x20match\x20`end_closed`.\n\n\r\n\x05\x04\0\x02\x02\x06\x12\x04\x84\ + \x01\x04\x1d\n\r\n\x05\x04\0\x02\x02\x01\x12\x04\x84\x01\x1e(\n\r\n\x05\ + \x04\0\x02\x02\x03\x12\x04\x84\x01+,\n\x83\x01\n\x04\x04\0\x02\x03\x12\ + \x04\x88\x01\x04+\x1au\x20If\x20the\x20end\x20is\x20open,\x20then\x20the\ + \x20range\x20excludes\x20rows\x20whose\x20first\n\x20`len(end_open)`\x20\ + key\x20columns\x20exactly\x20match\x20`end_open`.\n\n\r\n\x05\x04\0\x02\ + \x03\x06\x12\x04\x88\x01\x04\x1d\n\r\n\x05\x04\0\x02\x03\x01\x12\x04\x88\ + \x01\x1e&\n\r\n\x05\x04\0\x02\x03\x03\x12\x04\x88\x01)*\n\x86\x03\n\x02\ + \x04\x01\x12\x06\x93\x01\0\xa2\x01\x01\x1a\xf7\x02\x20`KeySet`\x20define\ + s\x20a\x20collection\x20of\x20Cloud\x20Spanner\x20keys\x20and/or\x20key\ + \x20ranges.\x20All\n\x20the\x20keys\x20are\x20expected\x20to\x20be\x20in\ + \x20the\x20same\x20table\x20or\x20index.\x20The\x20keys\x20need\n\x20not\ + \x20be\x20sorted\x20in\x20any\x20particular\x20way.\n\n\x20If\x20the\x20\ + same\x20key\x20is\x20specified\x20multiple\x20times\x20in\x20the\x20set\ + \x20(for\x20example\n\x20if\x20two\x20ranges,\x20two\x20keys,\x20or\x20a\ + \x20key\x20and\x20a\x20range\x20overlap),\x20Cloud\x20Spanner\n\x20behav\ + es\x20as\x20if\x20the\x20key\x20were\x20only\x20specified\x20once.\n\n\ + \x0b\n\x03\x04\x01\x01\x12\x04\x93\x01\x08\x0e\n\x8a\x02\n\x04\x04\x01\ + \x02\0\x12\x04\x98\x01\x02.\x1a\xfb\x01\x20A\x20list\x20of\x20specific\ + \x20keys.\x20Entries\x20in\x20`keys`\x20should\x20have\x20exactly\x20as\ + \n\x20many\x20elements\x20as\x20there\x20are\x20columns\x20in\x20the\x20\ + primary\x20or\x20index\x20key\n\x20with\x20which\x20this\x20`KeySet`\x20\ + is\x20used.\x20\x20Individual\x20key\x20values\x20are\n\x20encoded\x20as\ + \x20described\x20[here][google.spanner.v1.TypeCode].\n\n\r\n\x05\x04\x01\ + \x02\0\x04\x12\x04\x98\x01\x02\n\n\r\n\x05\x04\x01\x02\0\x06\x12\x04\x98\ + \x01\x0b$\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\x98\x01%)\n\r\n\x05\x04\ + \x01\x02\0\x03\x12\x04\x98\x01,-\n\x86\x01\n\x04\x04\x01\x02\x01\x12\x04\ + \x9c\x01\x02\x1f\x1ax\x20A\x20list\x20of\x20key\x20ranges.\x20See\x20[Ke\ + yRange][google.spanner.v1.KeyRange]\x20for\x20more\x20information\x20abo\ + ut\n\x20key\x20range\x20specifications.\n\n\r\n\x05\x04\x01\x02\x01\x04\ + \x12\x04\x9c\x01\x02\n\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\x9c\x01\x0b\ + \x13\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\x9c\x01\x14\x1a\n\r\n\x05\x04\ + \x01\x02\x01\x03\x12\x04\x9c\x01\x1d\x1e\n\xce\x01\n\x04\x04\x01\x02\x02\ + \x12\x04\xa1\x01\x02\x0f\x1a\xbf\x01\x20For\x20convenience\x20`all`\x20c\ + an\x20be\x20set\x20to\x20`true`\x20to\x20indicate\x20that\x20this\n\x20`\ + KeySet`\x20matches\x20all\x20keys\x20in\x20the\x20table\x20or\x20index.\ + \x20Note\x20that\x20any\x20keys\n\x20specified\x20in\x20`keys`\x20or\x20\ + `ranges`\x20are\x20only\x20yielded\x20once.\n\n\x0f\n\x05\x04\x01\x02\ + \x02\x04\x12\x06\xa1\x01\x02\x9c\x01\x1f\n\r\n\x05\x04\x01\x02\x02\x05\ + \x12\x04\xa1\x01\x02\x06\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xa1\x01\ + \x07\n\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\xa1\x01\r\x0eb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mod.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mod.rs new file mode 100644 index 00000000..e16823d1 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mod.rs @@ -0,0 +1,10 @@ +pub mod keys; +pub mod mutation; +pub mod query_plan; +pub mod result_set; +pub mod spanner; +pub mod spanner_grpc; +pub mod transaction; +pub mod type_pb; + +pub(crate) use crate::empty; diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mutation.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mutation.rs new file mode 100644 index 00000000..df553ceb --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/mutation.rs @@ -0,0 +1,1176 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/mutation.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation { + // message oneof groups + pub operation: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation { + fn default() -> &'a Mutation { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum Mutation_oneof_operation { + insert(Mutation_Write), + update(Mutation_Write), + insert_or_update(Mutation_Write), + replace(Mutation_Write), + delete(Mutation_Delete), +} + +impl Mutation { + pub fn new() -> Mutation { + ::std::default::Default::default() + } + + // .google.spanner.v1.Mutation.Write insert = 1; + + + pub fn get_insert(&self) -> &Mutation_Write { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert(ref v)) => v, + _ => Mutation_Write::default_instance(), + } + } + pub fn clear_insert(&mut self) { + self.operation = ::std::option::Option::None; + } + + pub fn has_insert(&self) -> bool { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_insert(&mut self, v: Mutation_Write) { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert(v)) + } + + // Mutable pointer to the field. + pub fn mut_insert(&mut self) -> &mut Mutation_Write { + if let ::std::option::Option::Some(Mutation_oneof_operation::insert(_)) = self.operation { + } else { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert(Mutation_Write::new())); + } + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_insert(&mut self) -> Mutation_Write { + if self.has_insert() { + match self.operation.take() { + ::std::option::Option::Some(Mutation_oneof_operation::insert(v)) => v, + _ => panic!(), + } + } else { + Mutation_Write::new() + } + } + + // .google.spanner.v1.Mutation.Write update = 2; + + + pub fn get_update(&self) -> &Mutation_Write { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::update(ref v)) => v, + _ => Mutation_Write::default_instance(), + } + } + pub fn clear_update(&mut self) { + self.operation = ::std::option::Option::None; + } + + pub fn has_update(&self) -> bool { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::update(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_update(&mut self, v: Mutation_Write) { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::update(v)) + } + + // Mutable pointer to the field. + pub fn mut_update(&mut self) -> &mut Mutation_Write { + if let ::std::option::Option::Some(Mutation_oneof_operation::update(_)) = self.operation { + } else { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::update(Mutation_Write::new())); + } + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::update(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_update(&mut self) -> Mutation_Write { + if self.has_update() { + match self.operation.take() { + ::std::option::Option::Some(Mutation_oneof_operation::update(v)) => v, + _ => panic!(), + } + } else { + Mutation_Write::new() + } + } + + // .google.spanner.v1.Mutation.Write insert_or_update = 3; + + + pub fn get_insert_or_update(&self) -> &Mutation_Write { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(ref v)) => v, + _ => Mutation_Write::default_instance(), + } + } + pub fn clear_insert_or_update(&mut self) { + self.operation = ::std::option::Option::None; + } + + pub fn has_insert_or_update(&self) -> bool { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_insert_or_update(&mut self, v: Mutation_Write) { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(v)) + } + + // Mutable pointer to the field. + pub fn mut_insert_or_update(&mut self) -> &mut Mutation_Write { + if let ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(_)) = self.operation { + } else { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(Mutation_Write::new())); + } + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_insert_or_update(&mut self) -> Mutation_Write { + if self.has_insert_or_update() { + match self.operation.take() { + ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(v)) => v, + _ => panic!(), + } + } else { + Mutation_Write::new() + } + } + + // .google.spanner.v1.Mutation.Write replace = 4; + + + pub fn get_replace(&self) -> &Mutation_Write { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::replace(ref v)) => v, + _ => Mutation_Write::default_instance(), + } + } + pub fn clear_replace(&mut self) { + self.operation = ::std::option::Option::None; + } + + pub fn has_replace(&self) -> bool { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::replace(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_replace(&mut self, v: Mutation_Write) { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::replace(v)) + } + + // Mutable pointer to the field. + pub fn mut_replace(&mut self) -> &mut Mutation_Write { + if let ::std::option::Option::Some(Mutation_oneof_operation::replace(_)) = self.operation { + } else { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::replace(Mutation_Write::new())); + } + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::replace(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_replace(&mut self) -> Mutation_Write { + if self.has_replace() { + match self.operation.take() { + ::std::option::Option::Some(Mutation_oneof_operation::replace(v)) => v, + _ => panic!(), + } + } else { + Mutation_Write::new() + } + } + + // .google.spanner.v1.Mutation.Delete delete = 5; + + + pub fn get_delete(&self) -> &Mutation_Delete { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::delete(ref v)) => v, + _ => Mutation_Delete::default_instance(), + } + } + pub fn clear_delete(&mut self) { + self.operation = ::std::option::Option::None; + } + + pub fn has_delete(&self) -> bool { + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::delete(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_delete(&mut self, v: Mutation_Delete) { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::delete(v)) + } + + // Mutable pointer to the field. + pub fn mut_delete(&mut self) -> &mut Mutation_Delete { + if let ::std::option::Option::Some(Mutation_oneof_operation::delete(_)) = self.operation { + } else { + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::delete(Mutation_Delete::new())); + } + match self.operation { + ::std::option::Option::Some(Mutation_oneof_operation::delete(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_delete(&mut self) -> Mutation_Delete { + if self.has_delete() { + match self.operation.take() { + ::std::option::Option::Some(Mutation_oneof_operation::delete(v)) => v, + _ => panic!(), + } + } else { + Mutation_Delete::new() + } + } +} + +impl ::protobuf::Message for Mutation { + fn is_initialized(&self) -> bool { + if let Some(Mutation_oneof_operation::insert(ref v)) = self.operation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_operation::update(ref v)) = self.operation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_operation::insert_or_update(ref v)) = self.operation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_operation::replace(ref v)) = self.operation { + if !v.is_initialized() { + return false; + } + } + if let Some(Mutation_oneof_operation::delete(ref v)) = self.operation { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::update(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::insert_or_update(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::replace(is.read_message()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.operation = ::std::option::Option::Some(Mutation_oneof_operation::delete(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.operation { + match v { + &Mutation_oneof_operation::insert(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_operation::update(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_operation::insert_or_update(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_operation::replace(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Mutation_oneof_operation::delete(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.operation { + match v { + &Mutation_oneof_operation::insert(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_operation::update(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_operation::insert_or_update(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_operation::replace(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Mutation_oneof_operation::delete(ref v) => { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation { + Mutation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_Write>( + "insert", + Mutation::has_insert, + Mutation::get_insert, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_Write>( + "update", + Mutation::has_update, + Mutation::get_update, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_Write>( + "insert_or_update", + Mutation::has_insert_or_update, + Mutation::get_insert_or_update, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_Write>( + "replace", + Mutation::has_replace, + Mutation::get_replace, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mutation_Delete>( + "delete", + Mutation::has_delete, + Mutation::get_delete, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation, + }; + unsafe { + instance.get(Mutation::new) + } + } +} + +impl ::protobuf::Clear for Mutation { + fn clear(&mut self) { + self.operation = ::std::option::Option::None; + self.operation = ::std::option::Option::None; + self.operation = ::std::option::Option::None; + self.operation = ::std::option::Option::None; + self.operation = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_Write { + // message fields + pub table: ::std::string::String, + pub columns: ::protobuf::RepeatedField<::std::string::String>, + pub values: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_Write { + fn default() -> &'a Mutation_Write { + ::default_instance() + } +} + +impl Mutation_Write { + pub fn new() -> Mutation_Write { + ::std::default::Default::default() + } + + // string table = 1; + + + pub fn get_table(&self) -> &str { + &self.table + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: ::std::string::String) { + self.table = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut ::std::string::String { + &mut self.table + } + + // Take field + pub fn take_table(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table, ::std::string::String::new()) + } + + // repeated string columns = 2; + + + pub fn get_columns(&self) -> &[::std::string::String] { + &self.columns + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + + // Param is passed by value, moved + pub fn set_columns(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.columns = v; + } + + // Mutable pointer to the field. + pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.columns + } + + // Take field + pub fn take_columns(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.ListValue values = 3; + + + pub fn get_values(&self) -> &[::protobuf::well_known_types::ListValue] { + &self.values + } + pub fn clear_values(&mut self) { + self.values.clear(); + } + + // Param is passed by value, moved + pub fn set_values(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>) { + self.values = v; + } + + // Mutable pointer to the field. + pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + &mut self.values + } + + // Take field + pub fn take_values(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for Mutation_Write { + fn is_initialized(&self) -> bool { + for v in &self.values { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?; + }, + 2 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.columns)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table); + } + for value in &self.columns { + my_size += ::protobuf::rt::string_size(2, &value); + }; + for value in &self.values { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table.is_empty() { + os.write_string(1, &self.table)?; + } + for v in &self.columns { + os.write_string(2, &v)?; + }; + for v in &self.values { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_Write { + Mutation_Write::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table", + |m: &Mutation_Write| { &m.table }, + |m: &mut Mutation_Write| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "columns", + |m: &Mutation_Write| { &m.columns }, + |m: &mut Mutation_Write| { &mut m.columns }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::ListValue>>( + "values", + |m: &Mutation_Write| { &m.values }, + |m: &mut Mutation_Write| { &mut m.values }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_Write", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_Write { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_Write, + }; + unsafe { + instance.get(Mutation_Write::new) + } + } +} + +impl ::protobuf::Clear for Mutation_Write { + fn clear(&mut self) { + self.table.clear(); + self.columns.clear(); + self.values.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_Write { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_Write { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Mutation_Delete { + // message fields + pub table: ::std::string::String, + pub key_set: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mutation_Delete { + fn default() -> &'a Mutation_Delete { + ::default_instance() + } +} + +impl Mutation_Delete { + pub fn new() -> Mutation_Delete { + ::std::default::Default::default() + } + + // string table = 1; + + + pub fn get_table(&self) -> &str { + &self.table + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: ::std::string::String) { + self.table = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut ::std::string::String { + &mut self.table + } + + // Take field + pub fn take_table(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table, ::std::string::String::new()) + } + + // .google.spanner.v1.KeySet key_set = 2; + + + pub fn get_key_set(&self) -> &super::keys::KeySet { + self.key_set.as_ref().unwrap_or_else(|| super::keys::KeySet::default_instance()) + } + pub fn clear_key_set(&mut self) { + self.key_set.clear(); + } + + pub fn has_key_set(&self) -> bool { + self.key_set.is_some() + } + + // Param is passed by value, moved + pub fn set_key_set(&mut self, v: super::keys::KeySet) { + self.key_set = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key_set(&mut self) -> &mut super::keys::KeySet { + if self.key_set.is_none() { + self.key_set.set_default(); + } + self.key_set.as_mut().unwrap() + } + + // Take field + pub fn take_key_set(&mut self) -> super::keys::KeySet { + self.key_set.take().unwrap_or_else(|| super::keys::KeySet::new()) + } +} + +impl ::protobuf::Message for Mutation_Delete { + fn is_initialized(&self) -> bool { + for v in &self.key_set { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key_set)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.table.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.table); + } + if let Some(ref v) = self.key_set.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.table.is_empty() { + os.write_string(1, &self.table)?; + } + if let Some(ref v) = self.key_set.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mutation_Delete { + Mutation_Delete::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table", + |m: &Mutation_Delete| { &m.table }, + |m: &mut Mutation_Delete| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "key_set", + |m: &Mutation_Delete| { &m.key_set }, + |m: &mut Mutation_Delete| { &mut m.key_set }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Mutation_Delete", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mutation_Delete { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Mutation_Delete, + }; + unsafe { + instance.get(Mutation_Delete::new) + } + } +} + +impl ::protobuf::Clear for Mutation_Delete { + fn clear(&mut self) { + self.table.clear(); + self.key_set.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mutation_Delete { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mutation_Delete { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x20google/spanner/v1/mutation.proto\x12\x11google.spanner.v1\x1a\x1cg\ + oogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1cg\ + oogle/spanner/v1/keys.proto\"\x9e\x04\n\x08Mutation\x12;\n\x06insert\x18\ + \x01\x20\x01(\x0b2!.google.spanner.v1.Mutation.WriteH\0R\x06insert\x12;\ + \n\x06update\x18\x02\x20\x01(\x0b2!.google.spanner.v1.Mutation.WriteH\0R\ + \x06update\x12M\n\x10insert_or_update\x18\x03\x20\x01(\x0b2!.google.span\ + ner.v1.Mutation.WriteH\0R\x0einsertOrUpdate\x12=\n\x07replace\x18\x04\ + \x20\x01(\x0b2!.google.spanner.v1.Mutation.WriteH\0R\x07replace\x12<\n\ + \x06delete\x18\x05\x20\x01(\x0b2\".google.spanner.v1.Mutation.DeleteH\0R\ + \x06delete\x1ak\n\x05Write\x12\x14\n\x05table\x18\x01\x20\x01(\tR\x05tab\ + le\x12\x18\n\x07columns\x18\x02\x20\x03(\tR\x07columns\x122\n\x06values\ + \x18\x03\x20\x03(\x0b2\x1a.google.protobuf.ListValueR\x06values\x1aR\n\ + \x06Delete\x12\x14\n\x05table\x18\x01\x20\x01(\tR\x05table\x122\n\x07key\ + _set\x18\x02\x20\x01(\x0b2\x19.google.spanner.v1.KeySetR\x06keySetB\x0b\ + \n\toperationB\x96\x01\n\x15com.google.spanner.v1B\rMutationProtoP\x01Z8\ + google.golang.org/genproto/googleapis/spanner/v1;spanner\xaa\x02\x17Goog\ + le.Cloud.Spanner.V1\xca\x02\x17Google\\Cloud\\Spanner\\V1J\xf1\x1f\n\x06\ + \x12\x04\x0e\0^\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Co\ + pyright\x202018\x20Google\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apac\ + he\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20ma\ + y\x20not\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\ + \x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\ + \x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/\ + LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\ + \x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\ + \x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20B\ + ASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIN\ + D,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20\ + for\x20the\x20specific\x20language\x20governing\x20permissions\x20and\n\ + \x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\ + \x10\0\x1a\n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\ + \0&\n\t\n\x02\x03\x02\x12\x03\x14\0&\n\x08\n\x01\x08\x12\x03\x16\04\n\t\ + \n\x02\x08%\x12\x03\x16\04\n\x08\n\x01\x08\x12\x03\x17\0O\n\t\n\x02\x08\ + \x0b\x12\x03\x17\0O\n\x08\n\x01\x08\x12\x03\x18\0\"\n\t\n\x02\x08\n\x12\ + \x03\x18\0\"\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\x02\x08\x08\x12\x03\ + \x19\0.\n\x08\n\x01\x08\x12\x03\x1a\0.\n\t\n\x02\x08\x01\x12\x03\x1a\0.\ + \n\x08\n\x01\x08\x12\x03\x1b\04\n\t\n\x02\x08)\x12\x03\x1b\04\n\xbe\x01\ + \n\x02\x04\0\x12\x04!\0^\x01\x1a\xb1\x01\x20A\x20modification\x20to\x20o\ + ne\x20or\x20more\x20Cloud\x20Spanner\x20rows.\x20\x20Mutations\x20can\ + \x20be\n\x20applied\x20to\x20a\x20Cloud\x20Spanner\x20database\x20by\x20\ + sending\x20them\x20in\x20a\n\x20[Commit][google.spanner.v1.Spanner.Commi\ + t]\x20call.\n\n\n\n\x03\x04\0\x01\x12\x03!\x08\x10\n\xf7\x01\n\x04\x04\0\ + \x03\0\x12\x04$\x028\x03\x1a\xe8\x01\x20Arguments\x20to\x20[insert][goog\ + le.spanner.v1.Mutation.insert],\x20[update][google.spanner.v1.Mutation.u\ + pdate],\x20[insert_or_update][google.spanner.v1.Mutation.insert_or_updat\ + e],\x20and\n\x20[replace][google.spanner.v1.Mutation.replace]\x20operati\ + ons.\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03$\n\x0f\n@\n\x06\x04\0\x03\0\ + \x02\0\x12\x03&\x04\x15\x1a1\x20Required.\x20The\x20table\x20whose\x20ro\ + ws\x20will\x20be\x20written.\n\n\x0f\n\x07\x04\0\x03\0\x02\0\x04\x12\x04\ + &\x04$\x11\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03&\x04\n\n\x0e\n\x07\ + \x04\0\x03\0\x02\0\x01\x12\x03&\x0b\x10\n\x0e\n\x07\x04\0\x03\0\x02\0\ + \x03\x12\x03&\x13\x14\n\x82\x02\n\x06\x04\0\x03\0\x02\x01\x12\x03-\x04\ + \x20\x1a\xf2\x01\x20The\x20names\x20of\x20the\x20columns\x20in\x20[table\ + ][google.spanner.v1.Mutation.Write.table]\x20to\x20be\x20written.\n\n\ + \x20The\x20list\x20of\x20columns\x20must\x20contain\x20enough\x20columns\ + \x20to\x20allow\n\x20Cloud\x20Spanner\x20to\x20derive\x20values\x20for\ + \x20all\x20primary\x20key\x20columns\x20in\x20the\n\x20row(s)\x20to\x20b\ + e\x20modified.\n\n\x0e\n\x07\x04\0\x03\0\x02\x01\x04\x12\x03-\x04\x0c\n\ + \x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x03-\r\x13\n\x0e\n\x07\x04\0\x03\ + \0\x02\x01\x01\x12\x03-\x14\x1b\n\x0e\n\x07\x04\0\x03\0\x02\x01\x03\x12\ + \x03-\x1e\x1f\n\xf8\x04\n\x06\x04\0\x03\0\x02\x02\x12\x037\x042\x1a\xe8\ + \x04\x20The\x20values\x20to\x20be\x20written.\x20`values`\x20can\x20cont\ + ain\x20more\x20than\x20one\n\x20list\x20of\x20values.\x20If\x20it\x20doe\ + s,\x20then\x20multiple\x20rows\x20are\x20written,\x20one\n\x20for\x20eac\ + h\x20entry\x20in\x20`values`.\x20Each\x20list\x20in\x20`values`\x20must\ + \x20have\n\x20exactly\x20as\x20many\x20entries\x20as\x20there\x20are\x20\ + entries\x20in\x20[columns][google.spanner.v1.Mutation.Write.columns]\n\ + \x20above.\x20Sending\x20multiple\x20lists\x20is\x20equivalent\x20to\x20\ + sending\x20multiple\n\x20`Mutation`s,\x20each\x20containing\x20one\x20`v\ + alues`\x20entry\x20and\x20repeating\n\x20[table][google.spanner.v1.Mutat\ + ion.Write.table]\x20and\x20[columns][google.spanner.v1.Mutation.Write.co\ + lumns].\x20Individual\x20values\x20in\x20each\x20list\x20are\n\x20encode\ + d\x20as\x20described\x20[here][google.spanner.v1.TypeCode].\n\n\x0e\n\ + \x07\x04\0\x03\0\x02\x02\x04\x12\x037\x04\x0c\n\x0e\n\x07\x04\0\x03\0\ + \x02\x02\x06\x12\x037\r&\n\x0e\n\x07\x04\0\x03\0\x02\x02\x01\x12\x037'-\ + \n\x0e\n\x07\x04\0\x03\0\x02\x02\x03\x12\x03701\nT\n\x04\x04\0\x03\x01\ + \x12\x04;\x02C\x03\x1aF\x20Arguments\x20to\x20[delete][google.spanner.v1\ + .Mutation.delete]\x20operations.\n\n\x0c\n\x05\x04\0\x03\x01\x01\x12\x03\ + ;\n\x10\n@\n\x06\x04\0\x03\x01\x02\0\x12\x03=\x04\x15\x1a1\x20Required.\ + \x20The\x20table\x20whose\x20rows\x20will\x20be\x20deleted.\n\n\x0f\n\ + \x07\x04\0\x03\x01\x02\0\x04\x12\x04=\x04;\x12\n\x0e\n\x07\x04\0\x03\x01\ + \x02\0\x05\x12\x03=\x04\n\n\x0e\n\x07\x04\0\x03\x01\x02\0\x01\x12\x03=\ + \x0b\x10\n\x0e\n\x07\x04\0\x03\x01\x02\0\x03\x12\x03=\x13\x14\n\xd7\x01\ + \n\x06\x04\0\x03\x01\x02\x01\x12\x03B\x04\x17\x1a\xc7\x01\x20Required.\ + \x20The\x20primary\x20keys\x20of\x20the\x20rows\x20within\x20[table][goo\ + gle.spanner.v1.Mutation.Delete.table]\x20to\x20delete.\n\x20Delete\x20is\ + \x20idempotent.\x20The\x20transaction\x20will\x20succeed\x20even\x20if\ + \x20some\x20or\x20all\n\x20rows\x20do\x20not\x20exist.\n\n\x0f\n\x07\x04\ + \0\x03\x01\x02\x01\x04\x12\x04B\x04=\x15\n\x0e\n\x07\x04\0\x03\x01\x02\ + \x01\x06\x12\x03B\x04\n\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x01\x12\x03B\ + \x0b\x12\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x03\x12\x03B\x15\x16\n3\n\x04\ + \x04\0\x08\0\x12\x04F\x02]\x03\x1a%\x20Required.\x20The\x20operation\x20\ + to\x20perform.\n\n\x0c\n\x05\x04\0\x08\0\x01\x12\x03F\x08\x11\n\x89\x01\ + \n\x04\x04\0\x02\0\x12\x03I\x04\x15\x1a|\x20Insert\x20new\x20rows\x20in\ + \x20a\x20table.\x20If\x20any\x20of\x20the\x20rows\x20already\x20exist,\n\ + \x20the\x20write\x20or\x20transaction\x20fails\x20with\x20error\x20`ALRE\ + ADY_EXISTS`.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03I\x04\t\n\x0c\n\x05\ + \x04\0\x02\0\x01\x12\x03I\n\x10\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03I\x13\ + \x14\n\x89\x01\n\x04\x04\0\x02\x01\x12\x03M\x04\x15\x1a|\x20Update\x20ex\ + isting\x20rows\x20in\x20a\x20table.\x20If\x20any\x20of\x20the\x20rows\ + \x20does\x20not\n\x20already\x20exist,\x20the\x20transaction\x20fails\ + \x20with\x20error\x20`NOT_FOUND`.\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\ + \x03M\x04\t\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03M\n\x10\n\x0c\n\x05\x04\ + \0\x02\x01\x03\x12\x03M\x13\x14\n\xe1\x01\n\x04\x04\0\x02\x02\x12\x03R\ + \x04\x1f\x1a\xd3\x01\x20Like\x20[insert][google.spanner.v1.Mutation.inse\ + rt],\x20except\x20that\x20if\x20the\x20row\x20already\x20exists,\x20then\ + \n\x20its\x20column\x20values\x20are\x20overwritten\x20with\x20the\x20on\ + es\x20provided.\x20Any\n\x20column\x20values\x20not\x20explicitly\x20wri\ + tten\x20are\x20preserved.\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03R\x04\t\ + \n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03R\n\x1a\n\x0c\n\x05\x04\0\x02\x02\ + \x03\x12\x03R\x1d\x1e\n\xb3\x02\n\x04\x04\0\x02\x03\x12\x03X\x04\x16\x1a\ + \xa5\x02\x20Like\x20[insert][google.spanner.v1.Mutation.insert],\x20exce\ + pt\x20that\x20if\x20the\x20row\x20already\x20exists,\x20it\x20is\n\x20de\ + leted,\x20and\x20the\x20column\x20values\x20provided\x20are\x20inserted\ + \n\x20instead.\x20Unlike\x20[insert_or_update][google.spanner.v1.Mutatio\ + n.insert_or_update],\x20this\x20means\x20any\x20values\x20not\n\x20expli\ + citly\x20written\x20become\x20`NULL`.\n\n\x0c\n\x05\x04\0\x02\x03\x06\ + \x12\x03X\x04\t\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03X\n\x11\n\x0c\n\x05\ + \x04\0\x02\x03\x03\x12\x03X\x14\x15\n^\n\x04\x04\0\x02\x04\x12\x03\\\x04\ + \x16\x1aQ\x20Delete\x20rows\x20from\x20a\x20table.\x20Succeeds\x20whethe\ + r\x20or\x20not\x20the\x20named\n\x20rows\x20were\x20present.\n\n\x0c\n\ + \x05\x04\0\x02\x04\x06\x12\x03\\\x04\n\n\x0c\n\x05\x04\0\x02\x04\x01\x12\ + \x03\\\x0b\x11\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03\\\x14\x15b\x06proto\ + 3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/query_plan.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/query_plan.rs new file mode 100644 index 00000000..b7da4404 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/query_plan.rs @@ -0,0 +1,1360 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/query_plan.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct PlanNode { + // message fields + pub index: i32, + pub kind: PlanNode_Kind, + pub display_name: ::std::string::String, + pub child_links: ::protobuf::RepeatedField, + pub short_representation: ::protobuf::SingularPtrField, + pub metadata: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>, + pub execution_stats: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PlanNode { + fn default() -> &'a PlanNode { + ::default_instance() + } +} + +impl PlanNode { + pub fn new() -> PlanNode { + ::std::default::Default::default() + } + + // int32 index = 1; + + + pub fn get_index(&self) -> i32 { + self.index + } + pub fn clear_index(&mut self) { + self.index = 0; + } + + // Param is passed by value, moved + pub fn set_index(&mut self, v: i32) { + self.index = v; + } + + // .google.spanner.v1.PlanNode.Kind kind = 2; + + + pub fn get_kind(&self) -> PlanNode_Kind { + self.kind + } + pub fn clear_kind(&mut self) { + self.kind = PlanNode_Kind::KIND_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_kind(&mut self, v: PlanNode_Kind) { + self.kind = v; + } + + // string display_name = 3; + + + pub fn get_display_name(&self) -> &str { + &self.display_name + } + pub fn clear_display_name(&mut self) { + self.display_name.clear(); + } + + // Param is passed by value, moved + pub fn set_display_name(&mut self, v: ::std::string::String) { + self.display_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_display_name(&mut self) -> &mut ::std::string::String { + &mut self.display_name + } + + // Take field + pub fn take_display_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.display_name, ::std::string::String::new()) + } + + // repeated .google.spanner.v1.PlanNode.ChildLink child_links = 4; + + + pub fn get_child_links(&self) -> &[PlanNode_ChildLink] { + &self.child_links + } + pub fn clear_child_links(&mut self) { + self.child_links.clear(); + } + + // Param is passed by value, moved + pub fn set_child_links(&mut self, v: ::protobuf::RepeatedField) { + self.child_links = v; + } + + // Mutable pointer to the field. + pub fn mut_child_links(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.child_links + } + + // Take field + pub fn take_child_links(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.child_links, ::protobuf::RepeatedField::new()) + } + + // .google.spanner.v1.PlanNode.ShortRepresentation short_representation = 5; + + + pub fn get_short_representation(&self) -> &PlanNode_ShortRepresentation { + self.short_representation.as_ref().unwrap_or_else(|| PlanNode_ShortRepresentation::default_instance()) + } + pub fn clear_short_representation(&mut self) { + self.short_representation.clear(); + } + + pub fn has_short_representation(&self) -> bool { + self.short_representation.is_some() + } + + // Param is passed by value, moved + pub fn set_short_representation(&mut self, v: PlanNode_ShortRepresentation) { + self.short_representation = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_short_representation(&mut self) -> &mut PlanNode_ShortRepresentation { + if self.short_representation.is_none() { + self.short_representation.set_default(); + } + self.short_representation.as_mut().unwrap() + } + + // Take field + pub fn take_short_representation(&mut self) -> PlanNode_ShortRepresentation { + self.short_representation.take().unwrap_or_else(|| PlanNode_ShortRepresentation::new()) + } + + // .google.protobuf.Struct metadata = 6; + + + pub fn get_metadata(&self) -> &::protobuf::well_known_types::Struct { + self.metadata.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance()) + } + pub fn clear_metadata(&mut self) { + self.metadata.clear(); + } + + pub fn has_metadata(&self) -> bool { + self.metadata.is_some() + } + + // Param is passed by value, moved + pub fn set_metadata(&mut self, v: ::protobuf::well_known_types::Struct) { + self.metadata = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_metadata(&mut self) -> &mut ::protobuf::well_known_types::Struct { + if self.metadata.is_none() { + self.metadata.set_default(); + } + self.metadata.as_mut().unwrap() + } + + // Take field + pub fn take_metadata(&mut self) -> ::protobuf::well_known_types::Struct { + self.metadata.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new()) + } + + // .google.protobuf.Struct execution_stats = 7; + + + pub fn get_execution_stats(&self) -> &::protobuf::well_known_types::Struct { + self.execution_stats.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance()) + } + pub fn clear_execution_stats(&mut self) { + self.execution_stats.clear(); + } + + pub fn has_execution_stats(&self) -> bool { + self.execution_stats.is_some() + } + + // Param is passed by value, moved + pub fn set_execution_stats(&mut self, v: ::protobuf::well_known_types::Struct) { + self.execution_stats = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_execution_stats(&mut self) -> &mut ::protobuf::well_known_types::Struct { + if self.execution_stats.is_none() { + self.execution_stats.set_default(); + } + self.execution_stats.as_mut().unwrap() + } + + // Take field + pub fn take_execution_stats(&mut self) -> ::protobuf::well_known_types::Struct { + self.execution_stats.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new()) + } +} + +impl ::protobuf::Message for PlanNode { + fn is_initialized(&self) -> bool { + for v in &self.child_links { + if !v.is_initialized() { + return false; + } + }; + for v in &self.short_representation { + if !v.is_initialized() { + return false; + } + }; + for v in &self.metadata { + if !v.is_initialized() { + return false; + } + }; + for v in &self.execution_stats { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.index = tmp; + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 2, &mut self.unknown_fields)? + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.child_links)?; + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.short_representation)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?; + }, + 7 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.execution_stats)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.index != 0 { + my_size += ::protobuf::rt::value_size(1, self.index, ::protobuf::wire_format::WireTypeVarint); + } + if self.kind != PlanNode_Kind::KIND_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(2, self.kind); + } + if !self.display_name.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.display_name); + } + for value in &self.child_links { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.short_representation.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.metadata.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.execution_stats.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.index != 0 { + os.write_int32(1, self.index)?; + } + if self.kind != PlanNode_Kind::KIND_UNSPECIFIED { + os.write_enum(2, self.kind.value())?; + } + if !self.display_name.is_empty() { + os.write_string(3, &self.display_name)?; + } + for v in &self.child_links { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.short_representation.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.metadata.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.execution_stats.as_ref() { + os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PlanNode { + PlanNode::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "index", + |m: &PlanNode| { &m.index }, + |m: &mut PlanNode| { &mut m.index }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "kind", + |m: &PlanNode| { &m.kind }, + |m: &mut PlanNode| { &mut m.kind }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "display_name", + |m: &PlanNode| { &m.display_name }, + |m: &mut PlanNode| { &mut m.display_name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "child_links", + |m: &PlanNode| { &m.child_links }, + |m: &mut PlanNode| { &mut m.child_links }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "short_representation", + |m: &PlanNode| { &m.short_representation }, + |m: &mut PlanNode| { &mut m.short_representation }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>( + "metadata", + |m: &PlanNode| { &m.metadata }, + |m: &mut PlanNode| { &mut m.metadata }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>( + "execution_stats", + |m: &PlanNode| { &m.execution_stats }, + |m: &mut PlanNode| { &mut m.execution_stats }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PlanNode", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PlanNode { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PlanNode, + }; + unsafe { + instance.get(PlanNode::new) + } + } +} + +impl ::protobuf::Clear for PlanNode { + fn clear(&mut self) { + self.index = 0; + self.kind = PlanNode_Kind::KIND_UNSPECIFIED; + self.display_name.clear(); + self.child_links.clear(); + self.short_representation.clear(); + self.metadata.clear(); + self.execution_stats.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PlanNode { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PlanNode { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PlanNode_ChildLink { + // message fields + pub child_index: i32, + pub field_type: ::std::string::String, + pub variable: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PlanNode_ChildLink { + fn default() -> &'a PlanNode_ChildLink { + ::default_instance() + } +} + +impl PlanNode_ChildLink { + pub fn new() -> PlanNode_ChildLink { + ::std::default::Default::default() + } + + // int32 child_index = 1; + + + pub fn get_child_index(&self) -> i32 { + self.child_index + } + pub fn clear_child_index(&mut self) { + self.child_index = 0; + } + + // Param is passed by value, moved + pub fn set_child_index(&mut self, v: i32) { + self.child_index = v; + } + + // string type = 2; + + + pub fn get_field_type(&self) -> &str { + &self.field_type + } + pub fn clear_field_type(&mut self) { + self.field_type.clear(); + } + + // Param is passed by value, moved + pub fn set_field_type(&mut self, v: ::std::string::String) { + self.field_type = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_field_type(&mut self) -> &mut ::std::string::String { + &mut self.field_type + } + + // Take field + pub fn take_field_type(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.field_type, ::std::string::String::new()) + } + + // string variable = 3; + + + pub fn get_variable(&self) -> &str { + &self.variable + } + pub fn clear_variable(&mut self) { + self.variable.clear(); + } + + // Param is passed by value, moved + pub fn set_variable(&mut self, v: ::std::string::String) { + self.variable = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_variable(&mut self) -> &mut ::std::string::String { + &mut self.variable + } + + // Take field + pub fn take_variable(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.variable, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for PlanNode_ChildLink { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.child_index = tmp; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variable)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.child_index != 0 { + my_size += ::protobuf::rt::value_size(1, self.child_index, ::protobuf::wire_format::WireTypeVarint); + } + if !self.field_type.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.field_type); + } + if !self.variable.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.variable); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.child_index != 0 { + os.write_int32(1, self.child_index)?; + } + if !self.field_type.is_empty() { + os.write_string(2, &self.field_type)?; + } + if !self.variable.is_empty() { + os.write_string(3, &self.variable)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PlanNode_ChildLink { + PlanNode_ChildLink::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "child_index", + |m: &PlanNode_ChildLink| { &m.child_index }, + |m: &mut PlanNode_ChildLink| { &mut m.child_index }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "type", + |m: &PlanNode_ChildLink| { &m.field_type }, + |m: &mut PlanNode_ChildLink| { &mut m.field_type }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "variable", + |m: &PlanNode_ChildLink| { &m.variable }, + |m: &mut PlanNode_ChildLink| { &mut m.variable }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PlanNode_ChildLink", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PlanNode_ChildLink { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PlanNode_ChildLink, + }; + unsafe { + instance.get(PlanNode_ChildLink::new) + } + } +} + +impl ::protobuf::Clear for PlanNode_ChildLink { + fn clear(&mut self) { + self.child_index = 0; + self.field_type.clear(); + self.variable.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PlanNode_ChildLink { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PlanNode_ChildLink { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PlanNode_ShortRepresentation { + // message fields + pub description: ::std::string::String, + pub subqueries: ::std::collections::HashMap<::std::string::String, i32>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PlanNode_ShortRepresentation { + fn default() -> &'a PlanNode_ShortRepresentation { + ::default_instance() + } +} + +impl PlanNode_ShortRepresentation { + pub fn new() -> PlanNode_ShortRepresentation { + ::std::default::Default::default() + } + + // string description = 1; + + + pub fn get_description(&self) -> &str { + &self.description + } + pub fn clear_description(&mut self) { + self.description.clear(); + } + + // Param is passed by value, moved + pub fn set_description(&mut self, v: ::std::string::String) { + self.description = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_description(&mut self) -> &mut ::std::string::String { + &mut self.description + } + + // Take field + pub fn take_description(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.description, ::std::string::String::new()) + } + + // repeated .google.spanner.v1.PlanNode.ShortRepresentation.SubqueriesEntry subqueries = 2; + + + pub fn get_subqueries(&self) -> &::std::collections::HashMap<::std::string::String, i32> { + &self.subqueries + } + pub fn clear_subqueries(&mut self) { + self.subqueries.clear(); + } + + // Param is passed by value, moved + pub fn set_subqueries(&mut self, v: ::std::collections::HashMap<::std::string::String, i32>) { + self.subqueries = v; + } + + // Mutable pointer to the field. + pub fn mut_subqueries(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, i32> { + &mut self.subqueries + } + + // Take field + pub fn take_subqueries(&mut self) -> ::std::collections::HashMap<::std::string::String, i32> { + ::std::mem::replace(&mut self.subqueries, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for PlanNode_ShortRepresentation { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(wire_type, is, &mut self.subqueries)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.description.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.description); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(2, &self.subqueries); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.description.is_empty() { + os.write_string(1, &self.description)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(2, &self.subqueries, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PlanNode_ShortRepresentation { + PlanNode_ShortRepresentation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "description", + |m: &PlanNode_ShortRepresentation| { &m.description }, + |m: &mut PlanNode_ShortRepresentation| { &mut m.description }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>( + "subqueries", + |m: &PlanNode_ShortRepresentation| { &m.subqueries }, + |m: &mut PlanNode_ShortRepresentation| { &mut m.subqueries }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PlanNode_ShortRepresentation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PlanNode_ShortRepresentation { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PlanNode_ShortRepresentation, + }; + unsafe { + instance.get(PlanNode_ShortRepresentation::new) + } + } +} + +impl ::protobuf::Clear for PlanNode_ShortRepresentation { + fn clear(&mut self) { + self.description.clear(); + self.subqueries.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PlanNode_ShortRepresentation { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PlanNode_ShortRepresentation { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum PlanNode_Kind { + KIND_UNSPECIFIED = 0, + RELATIONAL = 1, + SCALAR = 2, +} + +impl ::protobuf::ProtobufEnum for PlanNode_Kind { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(PlanNode_Kind::KIND_UNSPECIFIED), + 1 => ::std::option::Option::Some(PlanNode_Kind::RELATIONAL), + 2 => ::std::option::Option::Some(PlanNode_Kind::SCALAR), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [PlanNode_Kind] = &[ + PlanNode_Kind::KIND_UNSPECIFIED, + PlanNode_Kind::RELATIONAL, + PlanNode_Kind::SCALAR, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("PlanNode_Kind", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for PlanNode_Kind { +} + +impl ::std::default::Default for PlanNode_Kind { + fn default() -> Self { + PlanNode_Kind::KIND_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for PlanNode_Kind { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct QueryPlan { + // message fields + pub plan_nodes: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a QueryPlan { + fn default() -> &'a QueryPlan { + ::default_instance() + } +} + +impl QueryPlan { + pub fn new() -> QueryPlan { + ::std::default::Default::default() + } + + // repeated .google.spanner.v1.PlanNode plan_nodes = 1; + + + pub fn get_plan_nodes(&self) -> &[PlanNode] { + &self.plan_nodes + } + pub fn clear_plan_nodes(&mut self) { + self.plan_nodes.clear(); + } + + // Param is passed by value, moved + pub fn set_plan_nodes(&mut self, v: ::protobuf::RepeatedField) { + self.plan_nodes = v; + } + + // Mutable pointer to the field. + pub fn mut_plan_nodes(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.plan_nodes + } + + // Take field + pub fn take_plan_nodes(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.plan_nodes, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for QueryPlan { + fn is_initialized(&self) -> bool { + for v in &self.plan_nodes { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.plan_nodes)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.plan_nodes { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.plan_nodes { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> QueryPlan { + QueryPlan::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "plan_nodes", + |m: &QueryPlan| { &m.plan_nodes }, + |m: &mut QueryPlan| { &mut m.plan_nodes }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "QueryPlan", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static QueryPlan { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const QueryPlan, + }; + unsafe { + instance.get(QueryPlan::new) + } + } +} + +impl ::protobuf::Clear for QueryPlan { + fn clear(&mut self) { + self.plan_nodes.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for QueryPlan { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for QueryPlan { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\"google/spanner/v1/query_plan.proto\x12\x11google.spanner.v1\x1a\x1cg\ + oogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x8e\ + \x06\n\x08PlanNode\x12\x14\n\x05index\x18\x01\x20\x01(\x05R\x05index\x12\ + 4\n\x04kind\x18\x02\x20\x01(\x0e2\x20.google.spanner.v1.PlanNode.KindR\ + \x04kind\x12!\n\x0cdisplay_name\x18\x03\x20\x01(\tR\x0bdisplayName\x12F\ + \n\x0bchild_links\x18\x04\x20\x03(\x0b2%.google.spanner.v1.PlanNode.Chil\ + dLinkR\nchildLinks\x12b\n\x14short_representation\x18\x05\x20\x01(\x0b2/\ + .google.spanner.v1.PlanNode.ShortRepresentationR\x13shortRepresentation\ + \x123\n\x08metadata\x18\x06\x20\x01(\x0b2\x17.google.protobuf.StructR\ + \x08metadata\x12@\n\x0fexecution_stats\x18\x07\x20\x01(\x0b2\x17.google.\ + protobuf.StructR\x0eexecutionStats\x1a\\\n\tChildLink\x12\x1f\n\x0bchild\ + _index\x18\x01\x20\x01(\x05R\nchildIndex\x12\x12\n\x04type\x18\x02\x20\ + \x01(\tR\x04type\x12\x1a\n\x08variable\x18\x03\x20\x01(\tR\x08variable\ + \x1a\xd7\x01\n\x13ShortRepresentation\x12\x20\n\x0bdescription\x18\x01\ + \x20\x01(\tR\x0bdescription\x12_\n\nsubqueries\x18\x02\x20\x03(\x0b2?.go\ + ogle.spanner.v1.PlanNode.ShortRepresentation.SubqueriesEntryR\nsubquerie\ + s\x1a=\n\x0fSubqueriesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\ + \x12\x14\n\x05value\x18\x02\x20\x01(\x05R\x05value:\x028\x01\"8\n\x04Kin\ + d\x12\x14\n\x10KIND_UNSPECIFIED\x10\0\x12\x0e\n\nRELATIONAL\x10\x01\x12\ + \n\n\x06SCALAR\x10\x02\"G\n\tQueryPlan\x12:\n\nplan_nodes\x18\x01\x20\ + \x03(\x0b2\x1b.google.spanner.v1.PlanNodeR\tplanNodesB\x97\x01\n\x15com.\ + google.spanner.v1B\x0eQueryPlanProtoP\x01Z8google.golang.org/genproto/go\ + ogleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V1\xca\x02\ + \x17Google\\Cloud\\Spanner\\V1J\xc6*\n\x07\x12\x05\x0e\0\x80\x01\x01\n\ + \xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202018\x20Go\ + ogle\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Ver\ + sion\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20th\ + is\x20file\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\ + \x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\ + \x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Un\ + less\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\ + \x20writing,\x20software\n\x20distributed\x20under\x20the\x20License\x20\ + is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20\ + WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20expres\ + s\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\ + \x20language\x20governing\x20permissions\x20and\n\x20limitations\x20unde\ + r\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\n\t\n\x02\x03\0\ + \x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0&\n\x08\n\x01\x08\x12\x03\ + \x15\04\n\t\n\x02\x08%\x12\x03\x15\04\n\x08\n\x01\x08\x12\x03\x16\0O\n\t\ + \n\x02\x08\x0b\x12\x03\x16\0O\n\x08\n\x01\x08\x12\x03\x17\0\"\n\t\n\x02\ + \x08\n\x12\x03\x17\0\"\n\x08\n\x01\x08\x12\x03\x18\0/\n\t\n\x02\x08\x08\ + \x12\x03\x18\0/\n\x08\n\x01\x08\x12\x03\x19\0.\n\t\n\x02\x08\x01\x12\x03\ + \x19\0.\n\x08\n\x01\x08\x12\x03\x1a\04\n\t\n\x02\x08)\x12\x03\x1a\04\nw\ + \n\x02\x04\0\x12\x04\x1e\0x\x01\x1ak\x20Node\x20information\x20for\x20no\ + des\x20appearing\x20in\x20a\x20[QueryPlan.plan_nodes][google.spanner.v1.\ + QueryPlan.plan_nodes].\n\n\n\n\x03\x04\0\x01\x12\x03\x1e\x08\x10\n|\n\ + \x04\x04\0\x03\0\x12\x04!\x024\x03\x1an\x20Metadata\x20associated\x20wit\ + h\x20a\x20parent-child\x20relationship\x20appearing\x20in\x20a\n\x20[Pla\ + nNode][google.spanner.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\ + \x03!\n\x13\n3\n\x06\x04\0\x03\0\x02\0\x12\x03#\x04\x1a\x1a$\x20The\x20n\ + ode\x20to\x20which\x20the\x20link\x20points.\n\n\x0f\n\x07\x04\0\x03\0\ + \x02\0\x04\x12\x04#\x04!\x15\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03#\ + \x04\t\n\x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\x03#\n\x15\n\x0e\n\x07\x04\ + \0\x03\0\x02\0\x03\x12\x03#\x18\x19\n\x84\x02\n\x06\x04\0\x03\0\x02\x01\ + \x12\x03)\x04\x14\x1a\xf4\x01\x20The\x20type\x20of\x20the\x20link.\x20Fo\ + r\x20example,\x20in\x20Hash\x20Joins\x20this\x20could\x20be\x20used\x20t\ + o\n\x20distinguish\x20between\x20the\x20build\x20child\x20and\x20the\x20\ + probe\x20child,\x20or\x20in\x20the\x20case\n\x20of\x20the\x20child\x20be\ + ing\x20an\x20output\x20variable,\x20to\x20represent\x20the\x20tag\x20ass\ + ociated\n\x20with\x20the\x20output\x20variable.\n\n\x0f\n\x07\x04\0\x03\ + \0\x02\x01\x04\x12\x04)\x04#\x1a\n\x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\ + \x03)\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\x01\x01\x12\x03)\x0b\x0f\n\x0e\n\ + \x07\x04\0\x03\0\x02\x01\x03\x12\x03)\x12\x13\n\xfc\x03\n\x06\x04\0\x03\ + \0\x02\x02\x12\x033\x04\x18\x1a\xec\x03\x20Only\x20present\x20if\x20the\ + \x20child\x20node\x20is\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCAL\ + AR]\x20and\x20corresponds\n\x20to\x20an\x20output\x20variable\x20of\x20t\ + he\x20parent\x20node.\x20The\x20field\x20carries\x20the\x20name\x20of\n\ + \x20the\x20output\x20variable.\n\x20For\x20example,\x20a\x20`TableScan`\ + \x20operator\x20that\x20reads\x20rows\x20from\x20a\x20table\x20will\n\ + \x20have\x20child\x20links\x20to\x20the\x20`SCALAR`\x20nodes\x20represen\ + ting\x20the\x20output\x20variables\n\x20created\x20for\x20each\x20column\ + \x20that\x20is\x20read\x20by\x20the\x20operator.\x20The\x20corresponding\ + \n\x20`variable`\x20fields\x20will\x20be\x20set\x20to\x20the\x20variable\ + \x20names\x20assigned\x20to\x20the\n\x20columns.\n\n\x0f\n\x07\x04\0\x03\ + \0\x02\x02\x04\x12\x043\x04)\x14\n\x0e\n\x07\x04\0\x03\0\x02\x02\x05\x12\ + \x033\x04\n\n\x0e\n\x07\x04\0\x03\0\x02\x02\x01\x12\x033\x0b\x13\n\x0e\n\ + \x07\x04\0\x03\0\x02\x02\x03\x12\x033\x16\x17\n\x89\x01\n\x04\x04\0\x03\ + \x01\x12\x048\x02B\x03\x1a{\x20Condensed\x20representation\x20of\x20a\ + \x20node\x20and\x20its\x20subtree.\x20Only\x20present\x20for\n\x20`SCALA\ + R`\x20[PlanNode(s)][google.spanner.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\ + \x01\x01\x12\x038\n\x1d\nW\n\x06\x04\0\x03\x01\x02\0\x12\x03:\x04\x1b\ + \x1aH\x20A\x20string\x20representation\x20of\x20the\x20expression\x20sub\ + tree\x20rooted\x20at\x20this\x20node.\n\n\x0f\n\x07\x04\0\x03\x01\x02\0\ + \x04\x12\x04:\x048\x1f\n\x0e\n\x07\x04\0\x03\x01\x02\0\x05\x12\x03:\x04\ + \n\n\x0e\n\x07\x04\0\x03\x01\x02\0\x01\x12\x03:\x0b\x16\n\x0e\n\x07\x04\ + \0\x03\x01\x02\0\x03\x12\x03:\x19\x1a\n\xb4\x02\n\x06\x04\0\x03\x01\x02\ + \x01\x12\x03A\x04&\x1a\xa4\x02\x20A\x20mapping\x20of\x20(subquery\x20var\ + iable\x20name)\x20->\x20(subquery\x20node\x20id)\x20for\x20cases\n\x20wh\ + ere\x20the\x20`description`\x20string\x20of\x20this\x20node\x20reference\ + s\x20a\x20`SCALAR`\n\x20subquery\x20contained\x20in\x20the\x20expression\ + \x20subtree\x20rooted\x20at\x20this\x20node.\x20The\n\x20referenced\x20`\ + SCALAR`\x20subquery\x20may\x20not\x20necessarily\x20be\x20a\x20direct\ + \x20child\x20of\n\x20this\x20node.\n\n\x0f\n\x07\x04\0\x03\x01\x02\x01\ + \x04\x12\x04A\x04:\x1b\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x06\x12\x03A\ + \x04\x16\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x01\x12\x03A\x17!\n\x0e\n\x07\ + \x04\0\x03\x01\x02\x01\x03\x12\x03A$%\n\x9d\x01\n\x04\x04\0\x04\0\x12\ + \x04F\x02T\x03\x1a\x8e\x01\x20The\x20kind\x20of\x20[PlanNode][google.spa\ + nner.v1.PlanNode].\x20Distinguishes\x20between\x20the\x20two\x20differen\ + t\x20kinds\x20of\n\x20nodes\x20that\x20can\x20appear\x20in\x20a\x20query\ + \x20plan.\n\n\x0c\n\x05\x04\0\x04\0\x01\x12\x03F\x07\x0b\n\x1f\n\x06\x04\ + \0\x04\0\x02\0\x12\x03H\x04\x19\x1a\x10\x20Not\x20specified.\n\n\x0e\n\ + \x07\x04\0\x04\0\x02\0\x01\x12\x03H\x04\x14\n\x0e\n\x07\x04\0\x04\0\x02\ + \0\x02\x12\x03H\x17\x18\n\xe5\x01\n\x06\x04\0\x04\0\x02\x01\x12\x03M\x04\ + \x13\x1a\xd5\x01\x20Denotes\x20a\x20Relational\x20operator\x20node\x20in\ + \x20the\x20expression\x20tree.\x20Relational\n\x20operators\x20represent\ + \x20iterative\x20processing\x20of\x20rows\x20during\x20query\x20executio\ + n.\n\x20For\x20example,\x20a\x20`TableScan`\x20operation\x20that\x20read\ + s\x20rows\x20from\x20a\x20table.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\ + \x12\x03M\x04\x0e\n\x0e\n\x07\x04\0\x04\0\x02\x01\x02\x12\x03M\x11\x12\n\ + \xf7\x01\n\x06\x04\0\x04\0\x02\x02\x12\x03S\x04\x0f\x1a\xe7\x01\x20Denot\ + es\x20a\x20Scalar\x20node\x20in\x20the\x20expression\x20tree.\x20Scalar\ + \x20nodes\x20represent\n\x20non-iterable\x20entities\x20in\x20the\x20que\ + ry\x20plan.\x20For\x20example,\x20constants\x20or\n\x20arithmetic\x20ope\ + rators\x20appearing\x20inside\x20predicate\x20expressions\x20or\x20refer\ + ences\n\x20to\x20column\x20names.\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x01\ + \x12\x03S\x04\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x02\x12\x03S\r\x0e\n]\n\ + \x04\x04\0\x02\0\x12\x03W\x02\x12\x1aP\x20The\x20`PlanNode`'s\x20index\ + \x20in\x20[node\x20list][google.spanner.v1.QueryPlan.plan_nodes].\n\n\r\ + \n\x05\x04\0\x02\0\x04\x12\x04W\x02T\x03\n\x0c\n\x05\x04\0\x02\0\x05\x12\ + \x03W\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03W\x08\r\n\x0c\n\x05\x04\ + \0\x02\0\x03\x12\x03W\x10\x11\n\xc5\x02\n\x04\x04\0\x02\x01\x12\x03^\x02\ + \x10\x1a\xb7\x02\x20Used\x20to\x20determine\x20the\x20type\x20of\x20node\ + .\x20May\x20be\x20needed\x20for\x20visualizing\n\x20different\x20kinds\ + \x20of\x20nodes\x20differently.\x20For\x20example,\x20If\x20the\x20node\ + \x20is\x20a\n\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20nod\ + e,\x20it\x20will\x20have\x20a\x20condensed\x20representation\n\x20which\ + \x20can\x20be\x20used\x20to\x20directly\x20embed\x20a\x20description\x20\ + of\x20the\x20node\x20in\x20its\n\x20parent.\n\n\r\n\x05\x04\0\x02\x01\ + \x04\x12\x04^\x02W\x12\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03^\x02\x06\n\ + \x0c\n\x05\x04\0\x02\x01\x01\x12\x03^\x07\x0b\n\x0c\n\x05\x04\0\x02\x01\ + \x03\x12\x03^\x0e\x0f\n-\n\x04\x04\0\x02\x02\x12\x03a\x02\x1a\x1a\x20\ + \x20The\x20display\x20name\x20for\x20the\x20node.\n\n\r\n\x05\x04\0\x02\ + \x02\x04\x12\x04a\x02^\x10\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03a\x02\ + \x08\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03a\t\x15\n\x0c\n\x05\x04\0\x02\ + \x02\x03\x12\x03a\x18\x19\nR\n\x04\x04\0\x02\x03\x12\x03d\x02%\x1aE\x20L\ + ist\x20of\x20child\x20node\x20`index`es\x20and\x20their\x20relationship\ + \x20to\x20this\x20parent.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03d\x02\n\ + \n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03d\x0b\x14\n\x0c\n\x05\x04\0\x02\ + \x03\x01\x12\x03d\x15\x20\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03d#$\nc\n\ + \x04\x04\0\x02\x04\x12\x03g\x02/\x1aV\x20Condensed\x20representation\x20\ + for\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20nodes.\n\n\r\ + \n\x05\x04\0\x02\x04\x04\x12\x04g\x02d%\n\x0c\n\x05\x04\0\x02\x04\x06\ + \x12\x03g\x02\x15\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03g\x16*\n\x0c\n\ + \x05\x04\0\x02\x04\x03\x12\x03g-.\n\x90\x02\n\x04\x04\0\x02\x05\x12\x03q\ + \x02&\x1a\x82\x02\x20Attributes\x20relevant\x20to\x20the\x20node\x20cont\ + ained\x20in\x20a\x20group\x20of\x20key-value\x20pairs.\n\x20For\x20examp\ + le,\x20a\x20Parameter\x20Reference\x20node\x20could\x20have\x20the\x20fo\ + llowing\n\x20information\x20in\x20its\x20metadata:\n\n\x20\x20\x20\x20\ + \x20{\n\x20\x20\x20\x20\x20\x20\x20\"parameter_reference\":\x20\"param1\ + \",\n\x20\x20\x20\x20\x20\x20\x20\"parameter_type\":\x20\"array\"\n\x20\ + \x20\x20\x20\x20}\n\n\r\n\x05\x04\0\x02\x05\x04\x12\x04q\x02g/\n\x0c\n\ + \x05\x04\0\x02\x05\x06\x12\x03q\x02\x18\n\x0c\n\x05\x04\0\x02\x05\x01\ + \x12\x03q\x19!\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03q$%\n\xfe\x01\n\x04\ + \x04\0\x02\x06\x12\x03w\x02-\x1a\xf0\x01\x20The\x20execution\x20statisti\ + cs\x20associated\x20with\x20the\x20node,\x20contained\x20in\x20a\x20grou\ + p\x20of\n\x20key-value\x20pairs.\x20Only\x20present\x20if\x20the\x20plan\ + \x20was\x20returned\x20as\x20a\x20result\x20of\x20a\n\x20profile\x20quer\ + y.\x20For\x20example,\x20number\x20of\x20executions,\x20number\x20of\x20\ + rows/time\x20per\n\x20execution\x20etc.\n\n\r\n\x05\x04\0\x02\x06\x04\ + \x12\x04w\x02q&\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03w\x02\x18\n\x0c\n\ + \x05\x04\0\x02\x06\x01\x12\x03w\x19(\n\x0c\n\x05\x04\0\x02\x06\x03\x12\ + \x03w+,\nM\n\x02\x04\x01\x12\x05{\0\x80\x01\x01\x1a@\x20Contains\x20an\ + \x20ordered\x20list\x20of\x20nodes\x20appearing\x20in\x20the\x20query\ + \x20plan.\n\n\n\n\x03\x04\x01\x01\x12\x03{\x08\x11\n\xcd\x01\n\x04\x04\ + \x01\x02\0\x12\x03\x7f\x02#\x1a\xbf\x01\x20The\x20nodes\x20in\x20the\x20\ + query\x20plan.\x20Plan\x20nodes\x20are\x20returned\x20in\x20pre-order\ + \x20starting\n\x20with\x20the\x20plan\x20root.\x20Each\x20[PlanNode][goo\ + gle.spanner.v1.PlanNode]'s\x20`id`\x20corresponds\x20to\x20its\x20index\ + \x20in\n\x20`plan_nodes`.\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x7f\ + \x02\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03\x7f\x0b\x13\n\x0c\n\x05\x04\ + \x01\x02\0\x01\x12\x03\x7f\x14\x1e\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\ + \x7f!\"b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/result_set.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/result_set.rs new file mode 100644 index 00000000..15245e25 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/result_set.rs @@ -0,0 +1,1528 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/result_set.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct ResultSet { + // message fields + pub metadata: ::protobuf::SingularPtrField, + pub rows: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>, + pub stats: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ResultSet { + fn default() -> &'a ResultSet { + ::default_instance() + } +} + +impl ResultSet { + pub fn new() -> ResultSet { + ::std::default::Default::default() + } + + // .google.spanner.v1.ResultSetMetadata metadata = 1; + + + pub fn get_metadata(&self) -> &ResultSetMetadata { + self.metadata.as_ref().unwrap_or_else(|| ResultSetMetadata::default_instance()) + } + pub fn clear_metadata(&mut self) { + self.metadata.clear(); + } + + pub fn has_metadata(&self) -> bool { + self.metadata.is_some() + } + + // Param is passed by value, moved + pub fn set_metadata(&mut self, v: ResultSetMetadata) { + self.metadata = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_metadata(&mut self) -> &mut ResultSetMetadata { + if self.metadata.is_none() { + self.metadata.set_default(); + } + self.metadata.as_mut().unwrap() + } + + // Take field + pub fn take_metadata(&mut self) -> ResultSetMetadata { + self.metadata.take().unwrap_or_else(|| ResultSetMetadata::new()) + } + + // repeated .google.protobuf.ListValue rows = 2; + + + pub fn get_rows(&self) -> &[::protobuf::well_known_types::ListValue] { + &self.rows + } + pub fn clear_rows(&mut self) { + self.rows.clear(); + } + + // Param is passed by value, moved + pub fn set_rows(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>) { + self.rows = v; + } + + // Mutable pointer to the field. + pub fn mut_rows(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + &mut self.rows + } + + // Take field + pub fn take_rows(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> { + ::std::mem::replace(&mut self.rows, ::protobuf::RepeatedField::new()) + } + + // .google.spanner.v1.ResultSetStats stats = 3; + + + pub fn get_stats(&self) -> &ResultSetStats { + self.stats.as_ref().unwrap_or_else(|| ResultSetStats::default_instance()) + } + pub fn clear_stats(&mut self) { + self.stats.clear(); + } + + pub fn has_stats(&self) -> bool { + self.stats.is_some() + } + + // Param is passed by value, moved + pub fn set_stats(&mut self, v: ResultSetStats) { + self.stats = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_stats(&mut self) -> &mut ResultSetStats { + if self.stats.is_none() { + self.stats.set_default(); + } + self.stats.as_mut().unwrap() + } + + // Take field + pub fn take_stats(&mut self) -> ResultSetStats { + self.stats.take().unwrap_or_else(|| ResultSetStats::new()) + } +} + +impl ::protobuf::Message for ResultSet { + fn is_initialized(&self) -> bool { + for v in &self.metadata { + if !v.is_initialized() { + return false; + } + }; + for v in &self.rows { + if !v.is_initialized() { + return false; + } + }; + for v in &self.stats { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rows)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stats)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.metadata.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.rows { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.stats.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.metadata.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.rows { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.stats.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ResultSet { + ResultSet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "metadata", + |m: &ResultSet| { &m.metadata }, + |m: &mut ResultSet| { &mut m.metadata }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::ListValue>>( + "rows", + |m: &ResultSet| { &m.rows }, + |m: &mut ResultSet| { &mut m.rows }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "stats", + |m: &ResultSet| { &m.stats }, + |m: &mut ResultSet| { &mut m.stats }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ResultSet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ResultSet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ResultSet, + }; + unsafe { + instance.get(ResultSet::new) + } + } +} + +impl ::protobuf::Clear for ResultSet { + fn clear(&mut self) { + self.metadata.clear(); + self.rows.clear(); + self.stats.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ResultSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ResultSet { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartialResultSet { + // message fields + pub metadata: ::protobuf::SingularPtrField, + pub values: ::protobuf::RepeatedField<::protobuf::well_known_types::Value>, + pub chunked_value: bool, + pub resume_token: ::std::vec::Vec, + pub stats: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartialResultSet { + fn default() -> &'a PartialResultSet { + ::default_instance() + } +} + +impl PartialResultSet { + pub fn new() -> PartialResultSet { + ::std::default::Default::default() + } + + // .google.spanner.v1.ResultSetMetadata metadata = 1; + + + pub fn get_metadata(&self) -> &ResultSetMetadata { + self.metadata.as_ref().unwrap_or_else(|| ResultSetMetadata::default_instance()) + } + pub fn clear_metadata(&mut self) { + self.metadata.clear(); + } + + pub fn has_metadata(&self) -> bool { + self.metadata.is_some() + } + + // Param is passed by value, moved + pub fn set_metadata(&mut self, v: ResultSetMetadata) { + self.metadata = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_metadata(&mut self) -> &mut ResultSetMetadata { + if self.metadata.is_none() { + self.metadata.set_default(); + } + self.metadata.as_mut().unwrap() + } + + // Take field + pub fn take_metadata(&mut self) -> ResultSetMetadata { + self.metadata.take().unwrap_or_else(|| ResultSetMetadata::new()) + } + + // repeated .google.protobuf.Value values = 2; + + + pub fn get_values(&self) -> &[::protobuf::well_known_types::Value] { + &self.values + } + pub fn clear_values(&mut self) { + self.values.clear(); + } + + // Param is passed by value, moved + pub fn set_values(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Value>) { + self.values = v; + } + + // Mutable pointer to the field. + pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Value> { + &mut self.values + } + + // Take field + pub fn take_values(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Value> { + ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new()) + } + + // bool chunked_value = 3; + + + pub fn get_chunked_value(&self) -> bool { + self.chunked_value + } + pub fn clear_chunked_value(&mut self) { + self.chunked_value = false; + } + + // Param is passed by value, moved + pub fn set_chunked_value(&mut self, v: bool) { + self.chunked_value = v; + } + + // bytes resume_token = 4; + + + pub fn get_resume_token(&self) -> &[u8] { + &self.resume_token + } + pub fn clear_resume_token(&mut self) { + self.resume_token.clear(); + } + + // Param is passed by value, moved + pub fn set_resume_token(&mut self, v: ::std::vec::Vec) { + self.resume_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resume_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.resume_token + } + + // Take field + pub fn take_resume_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.resume_token, ::std::vec::Vec::new()) + } + + // .google.spanner.v1.ResultSetStats stats = 5; + + + pub fn get_stats(&self) -> &ResultSetStats { + self.stats.as_ref().unwrap_or_else(|| ResultSetStats::default_instance()) + } + pub fn clear_stats(&mut self) { + self.stats.clear(); + } + + pub fn has_stats(&self) -> bool { + self.stats.is_some() + } + + // Param is passed by value, moved + pub fn set_stats(&mut self, v: ResultSetStats) { + self.stats = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_stats(&mut self) -> &mut ResultSetStats { + if self.stats.is_none() { + self.stats.set_default(); + } + self.stats.as_mut().unwrap() + } + + // Take field + pub fn take_stats(&mut self) -> ResultSetStats { + self.stats.take().unwrap_or_else(|| ResultSetStats::new()) + } +} + +impl ::protobuf::Message for PartialResultSet { + fn is_initialized(&self) -> bool { + for v in &self.metadata { + if !v.is_initialized() { + return false; + } + }; + for v in &self.values { + if !v.is_initialized() { + return false; + } + }; + for v in &self.stats { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.chunked_value = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?; + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stats)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.metadata.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.values { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.chunked_value != false { + my_size += 2; + } + if !self.resume_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(4, &self.resume_token); + } + if let Some(ref v) = self.stats.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.metadata.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.values { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if self.chunked_value != false { + os.write_bool(3, self.chunked_value)?; + } + if !self.resume_token.is_empty() { + os.write_bytes(4, &self.resume_token)?; + } + if let Some(ref v) = self.stats.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartialResultSet { + PartialResultSet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "metadata", + |m: &PartialResultSet| { &m.metadata }, + |m: &mut PartialResultSet| { &mut m.metadata }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Value>>( + "values", + |m: &PartialResultSet| { &m.values }, + |m: &mut PartialResultSet| { &mut m.values }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "chunked_value", + |m: &PartialResultSet| { &m.chunked_value }, + |m: &mut PartialResultSet| { &mut m.chunked_value }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "resume_token", + |m: &PartialResultSet| { &m.resume_token }, + |m: &mut PartialResultSet| { &mut m.resume_token }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "stats", + |m: &PartialResultSet| { &m.stats }, + |m: &mut PartialResultSet| { &mut m.stats }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartialResultSet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartialResultSet { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartialResultSet, + }; + unsafe { + instance.get(PartialResultSet::new) + } + } +} + +impl ::protobuf::Clear for PartialResultSet { + fn clear(&mut self) { + self.metadata.clear(); + self.values.clear(); + self.chunked_value = false; + self.resume_token.clear(); + self.stats.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartialResultSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartialResultSet { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ResultSetMetadata { + // message fields + pub row_type: ::protobuf::SingularPtrField, + pub transaction: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ResultSetMetadata { + fn default() -> &'a ResultSetMetadata { + ::default_instance() + } +} + +impl ResultSetMetadata { + pub fn new() -> ResultSetMetadata { + ::std::default::Default::default() + } + + // .google.spanner.v1.StructType row_type = 1; + + + pub fn get_row_type(&self) -> &super::type_pb::StructType { + self.row_type.as_ref().unwrap_or_else(|| super::type_pb::StructType::default_instance()) + } + pub fn clear_row_type(&mut self) { + self.row_type.clear(); + } + + pub fn has_row_type(&self) -> bool { + self.row_type.is_some() + } + + // Param is passed by value, moved + pub fn set_row_type(&mut self, v: super::type_pb::StructType) { + self.row_type = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_row_type(&mut self) -> &mut super::type_pb::StructType { + if self.row_type.is_none() { + self.row_type.set_default(); + } + self.row_type.as_mut().unwrap() + } + + // Take field + pub fn take_row_type(&mut self) -> super::type_pb::StructType { + self.row_type.take().unwrap_or_else(|| super::type_pb::StructType::new()) + } + + // .google.spanner.v1.Transaction transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::Transaction { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::Transaction::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::Transaction) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::Transaction { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::Transaction { + self.transaction.take().unwrap_or_else(|| super::transaction::Transaction::new()) + } +} + +impl ::protobuf::Message for ResultSetMetadata { + fn is_initialized(&self) -> bool { + for v in &self.row_type { + if !v.is_initialized() { + return false; + } + }; + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.row_type)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.row_type.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.row_type.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ResultSetMetadata { + ResultSetMetadata::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "row_type", + |m: &ResultSetMetadata| { &m.row_type }, + |m: &mut ResultSetMetadata| { &mut m.row_type }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &ResultSetMetadata| { &m.transaction }, + |m: &mut ResultSetMetadata| { &mut m.transaction }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ResultSetMetadata", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ResultSetMetadata { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ResultSetMetadata, + }; + unsafe { + instance.get(ResultSetMetadata::new) + } + } +} + +impl ::protobuf::Clear for ResultSetMetadata { + fn clear(&mut self) { + self.row_type.clear(); + self.transaction.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ResultSetMetadata { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ResultSetMetadata { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ResultSetStats { + // message fields + pub query_plan: ::protobuf::SingularPtrField, + pub query_stats: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>, + // message oneof groups + pub row_count: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ResultSetStats { + fn default() -> &'a ResultSetStats { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum ResultSetStats_oneof_row_count { + row_count_exact(i64), + row_count_lower_bound(i64), +} + +impl ResultSetStats { + pub fn new() -> ResultSetStats { + ::std::default::Default::default() + } + + // .google.spanner.v1.QueryPlan query_plan = 1; + + + pub fn get_query_plan(&self) -> &super::query_plan::QueryPlan { + self.query_plan.as_ref().unwrap_or_else(|| super::query_plan::QueryPlan::default_instance()) + } + pub fn clear_query_plan(&mut self) { + self.query_plan.clear(); + } + + pub fn has_query_plan(&self) -> bool { + self.query_plan.is_some() + } + + // Param is passed by value, moved + pub fn set_query_plan(&mut self, v: super::query_plan::QueryPlan) { + self.query_plan = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_query_plan(&mut self) -> &mut super::query_plan::QueryPlan { + if self.query_plan.is_none() { + self.query_plan.set_default(); + } + self.query_plan.as_mut().unwrap() + } + + // Take field + pub fn take_query_plan(&mut self) -> super::query_plan::QueryPlan { + self.query_plan.take().unwrap_or_else(|| super::query_plan::QueryPlan::new()) + } + + // .google.protobuf.Struct query_stats = 2; + + + pub fn get_query_stats(&self) -> &::protobuf::well_known_types::Struct { + self.query_stats.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance()) + } + pub fn clear_query_stats(&mut self) { + self.query_stats.clear(); + } + + pub fn has_query_stats(&self) -> bool { + self.query_stats.is_some() + } + + // Param is passed by value, moved + pub fn set_query_stats(&mut self, v: ::protobuf::well_known_types::Struct) { + self.query_stats = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_query_stats(&mut self) -> &mut ::protobuf::well_known_types::Struct { + if self.query_stats.is_none() { + self.query_stats.set_default(); + } + self.query_stats.as_mut().unwrap() + } + + // Take field + pub fn take_query_stats(&mut self) -> ::protobuf::well_known_types::Struct { + self.query_stats.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new()) + } + + // int64 row_count_exact = 3; + + + pub fn get_row_count_exact(&self) -> i64 { + match self.row_count { + ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(v)) => v, + _ => 0, + } + } + pub fn clear_row_count_exact(&mut self) { + self.row_count = ::std::option::Option::None; + } + + pub fn has_row_count_exact(&self) -> bool { + match self.row_count { + ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_count_exact(&mut self, v: i64) { + self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(v)) + } + + // int64 row_count_lower_bound = 4; + + + pub fn get_row_count_lower_bound(&self) -> i64 { + match self.row_count { + ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(v)) => v, + _ => 0, + } + } + pub fn clear_row_count_lower_bound(&mut self) { + self.row_count = ::std::option::Option::None; + } + + pub fn has_row_count_lower_bound(&self) -> bool { + match self.row_count { + ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_row_count_lower_bound(&mut self, v: i64) { + self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(v)) + } +} + +impl ::protobuf::Message for ResultSetStats { + fn is_initialized(&self) -> bool { + for v in &self.query_plan { + if !v.is_initialized() { + return false; + } + }; + for v in &self.query_stats { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.query_plan)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.query_stats)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(is.read_int64()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(is.read_int64()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.query_plan.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.query_stats.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let ::std::option::Option::Some(ref v) = self.row_count { + match v { + &ResultSetStats_oneof_row_count::row_count_exact(v) => { + my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint); + }, + &ResultSetStats_oneof_row_count::row_count_lower_bound(v) => { + my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.query_plan.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.query_stats.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let ::std::option::Option::Some(ref v) = self.row_count { + match v { + &ResultSetStats_oneof_row_count::row_count_exact(v) => { + os.write_int64(3, v)?; + }, + &ResultSetStats_oneof_row_count::row_count_lower_bound(v) => { + os.write_int64(4, v)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ResultSetStats { + ResultSetStats::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "query_plan", + |m: &ResultSetStats| { &m.query_plan }, + |m: &mut ResultSetStats| { &mut m.query_plan }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>( + "query_stats", + |m: &ResultSetStats| { &m.query_stats }, + |m: &mut ResultSetStats| { &mut m.query_stats }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>( + "row_count_exact", + ResultSetStats::has_row_count_exact, + ResultSetStats::get_row_count_exact, + )); + fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>( + "row_count_lower_bound", + ResultSetStats::has_row_count_lower_bound, + ResultSetStats::get_row_count_lower_bound, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ResultSetStats", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ResultSetStats { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ResultSetStats, + }; + unsafe { + instance.get(ResultSetStats::new) + } + } +} + +impl ::protobuf::Clear for ResultSetStats { + fn clear(&mut self) { + self.query_plan.clear(); + self.query_stats.clear(); + self.row_count = ::std::option::Option::None; + self.row_count = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ResultSetStats { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ResultSetStats { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\"google/spanner/v1/result_set.proto\x12\x11google.spanner.v1\x1a\x1cg\ + oogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\"goo\ + gle/spanner/v1/query_plan.proto\x1a#google/spanner/v1/transaction.proto\ + \x1a\x1cgoogle/spanner/v1/type.proto\"\xb6\x01\n\tResultSet\x12@\n\x08me\ + tadata\x18\x01\x20\x01(\x0b2$.google.spanner.v1.ResultSetMetadataR\x08me\ + tadata\x12.\n\x04rows\x18\x02\x20\x03(\x0b2\x1a.google.protobuf.ListValu\ + eR\x04rows\x127\n\x05stats\x18\x03\x20\x01(\x0b2!.google.spanner.v1.Resu\ + ltSetStatsR\x05stats\"\x85\x02\n\x10PartialResultSet\x12@\n\x08metadata\ + \x18\x01\x20\x01(\x0b2$.google.spanner.v1.ResultSetMetadataR\x08metadata\ + \x12.\n\x06values\x18\x02\x20\x03(\x0b2\x16.google.protobuf.ValueR\x06va\ + lues\x12#\n\rchunked_value\x18\x03\x20\x01(\x08R\x0cchunkedValue\x12!\n\ + \x0cresume_token\x18\x04\x20\x01(\x0cR\x0bresumeToken\x127\n\x05stats\ + \x18\x05\x20\x01(\x0b2!.google.spanner.v1.ResultSetStatsR\x05stats\"\x8f\ + \x01\n\x11ResultSetMetadata\x128\n\x08row_type\x18\x01\x20\x01(\x0b2\x1d\ + .google.spanner.v1.StructTypeR\x07rowType\x12@\n\x0btransaction\x18\x02\ + \x20\x01(\x0b2\x1e.google.spanner.v1.TransactionR\x0btransaction\"\xf3\ + \x01\n\x0eResultSetStats\x12;\n\nquery_plan\x18\x01\x20\x01(\x0b2\x1c.go\ + ogle.spanner.v1.QueryPlanR\tqueryPlan\x128\n\x0bquery_stats\x18\x02\x20\ + \x01(\x0b2\x17.google.protobuf.StructR\nqueryStats\x12(\n\x0frow_count_e\ + xact\x18\x03\x20\x01(\x03H\0R\rrowCountExact\x123\n\x15row_count_lower_b\ + ound\x18\x04\x20\x01(\x03H\0R\x12rowCountLowerBoundB\x0b\n\trow_countB\ + \x9a\x01\n\x15com.google.spanner.v1B\x0eResultSetProtoP\x01Z8google.gola\ + ng.org/genproto/googleapis/spanner/v1;spanner\xf8\x01\x01\xaa\x02\x17Goo\ + gle.Cloud.Spanner.V1\xca\x02\x17Google\\Cloud\\Spanner\\V1J\xd0@\n\x07\ + \x12\x05\x0e\0\xcc\x01\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\ + \x04\x20Copyright\x202018\x20Google\x20LLC\n\n\x20Licensed\x20under\x20t\ + he\x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\ + \x20you\x20may\x20not\x20use\x20this\x20file\x20except\x20in\x20complian\ + ce\x20with\x20the\x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20\ + of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/\ + licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20la\ + w\x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\ + \x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20\ + IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20A\ + NY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20Li\ + cense\x20for\x20the\x20specific\x20language\x20governing\x20permissions\ + \x20and\n\x20limitations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\ + \x12\x03\x10\0\x1a\n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\ + \x03\x13\0&\n\t\n\x02\x03\x02\x12\x03\x14\0,\n\t\n\x02\x03\x03\x12\x03\ + \x15\0-\n\t\n\x02\x03\x04\x12\x03\x16\0&\n\x08\n\x01\x08\x12\x03\x18\0\ + \x1f\n\t\n\x02\x08\x1f\x12\x03\x18\0\x1f\n\x08\n\x01\x08\x12\x03\x19\04\ + \n\t\n\x02\x08%\x12\x03\x19\04\n\x08\n\x01\x08\x12\x03\x1a\0O\n\t\n\x02\ + \x08\x0b\x12\x03\x1a\0O\n\x08\n\x01\x08\x12\x03\x1b\0\"\n\t\n\x02\x08\n\ + \x12\x03\x1b\0\"\n\x08\n\x01\x08\x12\x03\x1c\0/\n\t\n\x02\x08\x08\x12\ + \x03\x1c\0/\n\x08\n\x01\x08\x12\x03\x1d\0.\n\t\n\x02\x08\x01\x12\x03\x1d\ + \0.\n\x08\n\x01\x08\x12\x03\x1e\04\n\t\n\x02\x08)\x12\x03\x1e\04\ny\n\ + \x02\x04\0\x12\x04#\08\x01\x1am\x20Results\x20from\x20[Read][google.span\ + ner.v1.Spanner.Read]\x20or\n\x20[ExecuteSql][google.spanner.v1.Spanner.E\ + xecuteSql].\n\n\n\n\x03\x04\0\x01\x12\x03#\x08\x11\nK\n\x04\x04\0\x02\0\ + \x12\x03%\x02!\x1a>\x20Metadata\x20about\x20the\x20result\x20set,\x20suc\ + h\x20as\x20row\x20type\x20information.\n\n\r\n\x05\x04\0\x02\0\x04\x12\ + \x04%\x02#\x13\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03%\x02\x13\n\x0c\n\x05\ + \x04\0\x02\0\x01\x12\x03%\x14\x1c\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03%\ + \x1f\x20\n\xde\x02\n\x04\x04\0\x02\x01\x12\x03-\x02.\x1a\xd0\x02\x20Each\ + \x20element\x20in\x20`rows`\x20is\x20a\x20row\x20whose\x20format\x20is\ + \x20defined\x20by\n\x20[metadata.row_type][google.spanner.v1.ResultSetMe\ + tadata.row_type].\x20The\x20ith\x20element\n\x20in\x20each\x20row\x20mat\ + ches\x20the\x20ith\x20field\x20in\n\x20[metadata.row_type][google.spanne\ + r.v1.ResultSetMetadata.row_type].\x20Elements\x20are\n\x20encoded\x20bas\ + ed\x20on\x20type\x20as\x20described\n\x20[here][google.spanner.v1.TypeCo\ + de].\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03-\x02\n\n\x0c\n\x05\x04\0\ + \x02\x01\x06\x12\x03-\x0b$\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03-%)\n\ + \x0c\n\x05\x04\0\x02\x01\x03\x12\x03-,-\n\xf5\x04\n\x04\x04\0\x02\x02\ + \x12\x037\x02\x1b\x1a\xe7\x04\x20Query\x20plan\x20and\x20execution\x20st\ + atistics\x20for\x20the\x20SQL\x20statement\x20that\n\x20produced\x20this\ + \x20result\x20set.\x20These\x20can\x20be\x20requested\x20by\x20setting\n\ + \x20[ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.q\ + uery_mode].\n\x20DML\x20statements\x20always\x20produce\x20stats\x20cont\ + aining\x20the\x20number\x20of\x20rows\n\x20modified,\x20unless\x20execut\ + ed\x20using\x20the\n\x20[ExecuteSqlRequest.QueryMode.PLAN][google.spanne\ + r.v1.ExecuteSqlRequest.QueryMode.PLAN]\x20[ExecuteSqlRequest.query_mode]\ + [google.spanner.v1.ExecuteSqlRequest.query_mode].\n\x20Other\x20fields\ + \x20may\x20or\x20may\x20not\x20be\x20populated,\x20based\x20on\x20the\n\ + \x20[ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.q\ + uery_mode].\n\n\r\n\x05\x04\0\x02\x02\x04\x12\x047\x02-.\n\x0c\n\x05\x04\ + \0\x02\x02\x06\x12\x037\x02\x10\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x037\ + \x11\x16\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x037\x19\x1a\n\xcc\x01\n\x02\ + \x04\x01\x12\x05=\0\xa0\x01\x01\x1a\xbe\x01\x20Partial\x20results\x20fro\ + m\x20a\x20streaming\x20read\x20or\x20SQL\x20query.\x20Streaming\x20reads\ + \x20and\n\x20SQL\x20queries\x20better\x20tolerate\x20large\x20result\x20\ + sets,\x20large\x20rows,\x20and\x20large\n\x20values,\x20but\x20are\x20a\ + \x20little\x20trickier\x20to\x20consume.\n\n\n\n\x03\x04\x01\x01\x12\x03\ + =\x08\x18\np\n\x04\x04\x01\x02\0\x12\x03@\x02!\x1ac\x20Metadata\x20about\ + \x20the\x20result\x20set,\x20such\x20as\x20row\x20type\x20information.\n\ + \x20Only\x20present\x20in\x20the\x20first\x20response.\n\n\r\n\x05\x04\ + \x01\x02\0\x04\x12\x04@\x02=\x1a\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03@\ + \x02\x13\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03@\x14\x1c\n\x0c\n\x05\x04\ + \x01\x02\0\x03\x12\x03@\x1f\x20\n\xc0\x15\n\x04\x04\x01\x02\x01\x12\x04\ + \x8b\x01\x02,\x1a\xb1\x15\x20A\x20streamed\x20result\x20set\x20consists\ + \x20of\x20a\x20stream\x20of\x20values,\x20which\x20might\n\x20be\x20spli\ + t\x20into\x20many\x20`PartialResultSet`\x20messages\x20to\x20accommodate\ + \n\x20large\x20rows\x20and/or\x20large\x20values.\x20Every\x20N\x20compl\ + ete\x20values\x20defines\x20a\n\x20row,\x20where\x20N\x20is\x20equal\x20\ + to\x20the\x20number\x20of\x20entries\x20in\n\x20[metadata.row_type.field\ + s][google.spanner.v1.StructType.fields].\n\n\x20Most\x20values\x20are\ + \x20encoded\x20based\x20on\x20type\x20as\x20described\n\x20[here][google\ + .spanner.v1.TypeCode].\n\n\x20It\x20is\x20possible\x20that\x20the\x20las\ + t\x20value\x20in\x20values\x20is\x20\"chunked\",\n\x20meaning\x20that\ + \x20the\x20rest\x20of\x20the\x20value\x20is\x20sent\x20in\x20subsequent\ + \n\x20`PartialResultSet`(s).\x20This\x20is\x20denoted\x20by\x20the\x20[c\ + hunked_value][google.spanner.v1.PartialResultSet.chunked_value]\n\x20fie\ + ld.\x20Two\x20or\x20more\x20chunked\x20values\x20can\x20be\x20merged\x20\ + to\x20form\x20a\n\x20complete\x20value\x20as\x20follows:\n\n\x20\x20\x20\ + *\x20`bool/number/null`:\x20cannot\x20be\x20chunked\n\x20\x20\x20*\x20`s\ + tring`:\x20concatenate\x20the\x20strings\n\x20\x20\x20*\x20`list`:\x20co\ + ncatenate\x20the\x20lists.\x20If\x20the\x20last\x20element\x20in\x20a\ + \x20list\x20is\x20a\n\x20\x20\x20\x20\x20`string`,\x20`list`,\x20or\x20`\ + object`,\x20merge\x20it\x20with\x20the\x20first\x20element\x20in\n\x20\ + \x20\x20\x20\x20the\x20next\x20list\x20by\x20applying\x20these\x20rules\ + \x20recursively.\n\x20\x20\x20*\x20`object`:\x20concatenate\x20the\x20(f\ + ield\x20name,\x20field\x20value)\x20pairs.\x20If\x20a\n\x20\x20\x20\x20\ + \x20field\x20name\x20is\x20duplicated,\x20then\x20apply\x20these\x20rule\ + s\x20recursively\n\x20\x20\x20\x20\x20to\x20merge\x20the\x20field\x20val\ + ues.\n\n\x20Some\x20examples\x20of\x20merging:\n\n\x20\x20\x20\x20\x20#\ + \x20Strings\x20are\x20concatenated.\n\x20\x20\x20\x20\x20\"foo\",\x20\"b\ + ar\"\x20=>\x20\"foobar\"\n\n\x20\x20\x20\x20\x20#\x20Lists\x20of\x20non-\ + strings\x20are\x20concatenated.\n\x20\x20\x20\x20\x20[2,\x203],\x20[4]\ + \x20=>\x20[2,\x203,\x204]\n\n\x20\x20\x20\x20\x20#\x20Lists\x20are\x20co\ + ncatenated,\x20but\x20the\x20last\x20and\x20first\x20elements\x20are\x20\ + merged\n\x20\x20\x20\x20\x20#\x20because\x20they\x20are\x20strings.\n\ + \x20\x20\x20\x20\x20[\"a\",\x20\"b\"],\x20[\"c\",\x20\"d\"]\x20=>\x20[\"\ + a\",\x20\"bc\",\x20\"d\"]\n\n\x20\x20\x20\x20\x20#\x20Lists\x20are\x20co\ + ncatenated,\x20but\x20the\x20last\x20and\x20first\x20elements\x20are\x20\ + merged\n\x20\x20\x20\x20\x20#\x20because\x20they\x20are\x20lists.\x20Rec\ + ursively,\x20the\x20last\x20and\x20first\x20elements\n\x20\x20\x20\x20\ + \x20#\x20of\x20the\x20inner\x20lists\x20are\x20merged\x20because\x20they\ + \x20are\x20strings.\n\x20\x20\x20\x20\x20[\"a\",\x20[\"b\",\x20\"c\"]],\ + \x20[[\"d\"],\x20\"e\"]\x20=>\x20[\"a\",\x20[\"b\",\x20\"cd\"],\x20\"e\"\ + ]\n\n\x20\x20\x20\x20\x20#\x20Non-overlapping\x20object\x20fields\x20are\ + \x20combined.\n\x20\x20\x20\x20\x20{\"a\":\x20\"1\"},\x20{\"b\":\x20\"2\ + \"}\x20=>\x20{\"a\":\x20\"1\",\x20\"b\":\x202\"}\n\n\x20\x20\x20\x20\x20\ + #\x20Overlapping\x20object\x20fields\x20are\x20merged.\n\x20\x20\x20\x20\ + \x20{\"a\":\x20\"1\"},\x20{\"a\":\x20\"2\"}\x20=>\x20{\"a\":\x20\"12\"}\ + \n\n\x20\x20\x20\x20\x20#\x20Examples\x20of\x20merging\x20objects\x20con\ + taining\x20lists\x20of\x20strings.\n\x20\x20\x20\x20\x20{\"a\":\x20[\"1\ + \"]},\x20{\"a\":\x20[\"2\"]}\x20=>\x20{\"a\":\x20[\"12\"]}\n\n\x20For\ + \x20a\x20more\x20complete\x20example,\x20suppose\x20a\x20streaming\x20SQ\ + L\x20query\x20is\n\x20yielding\x20a\x20result\x20set\x20whose\x20rows\ + \x20contain\x20a\x20single\x20string\n\x20field.\x20The\x20following\x20\ + `PartialResultSet`s\x20might\x20be\x20yielded:\n\n\x20\x20\x20\x20\x20{\ + \n\x20\x20\x20\x20\x20\x20\x20\"metadata\":\x20{\x20...\x20}\n\x20\x20\ + \x20\x20\x20\x20\x20\"values\":\x20[\"Hello\",\x20\"W\"]\n\x20\x20\x20\ + \x20\x20\x20\x20\"chunked_value\":\x20true\n\x20\x20\x20\x20\x20\x20\x20\ + \"resume_token\":\x20\"Af65...\"\n\x20\x20\x20\x20\x20}\n\x20\x20\x20\ + \x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"values\":\x20[\"orl\"]\n\x20\ + \x20\x20\x20\x20\x20\x20\"chunked_value\":\x20true\n\x20\x20\x20\x20\x20\ + \x20\x20\"resume_token\":\x20\"Bqp2...\"\n\x20\x20\x20\x20\x20}\n\x20\ + \x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"values\":\x20[\"d\"]\n\ + \x20\x20\x20\x20\x20\x20\x20\"resume_token\":\x20\"Zx1B...\"\n\x20\x20\ + \x20\x20\x20}\n\n\x20This\x20sequence\x20of\x20`PartialResultSet`s\x20en\ + codes\x20two\x20rows,\x20one\n\x20containing\x20the\x20field\x20value\ + \x20`\"Hello\"`,\x20and\x20a\x20second\x20containing\x20the\n\x20field\ + \x20value\x20`\"World\"\x20=\x20\"W\"\x20+\x20\"orl\"\x20+\x20\"d\"`.\n\ + \n\r\n\x05\x04\x01\x02\x01\x04\x12\x04\x8b\x01\x02\n\n\r\n\x05\x04\x01\ + \x02\x01\x06\x12\x04\x8b\x01\x0b\x20\n\r\n\x05\x04\x01\x02\x01\x01\x12\ + \x04\x8b\x01!'\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\x8b\x01*+\n\xdf\x01\ + \n\x04\x04\x01\x02\x02\x12\x04\x90\x01\x02\x19\x1a\xd0\x01\x20If\x20true\ + ,\x20then\x20the\x20final\x20value\x20in\x20[values][google.spanner.v1.P\ + artialResultSet.values]\x20is\x20chunked,\x20and\x20must\n\x20be\x20comb\ + ined\x20with\x20more\x20values\x20from\x20subsequent\x20`PartialResultSe\ + t`s\n\x20to\x20obtain\x20a\x20complete\x20field\x20value.\n\n\x0f\n\x05\ + \x04\x01\x02\x02\x04\x12\x06\x90\x01\x02\x8b\x01,\n\r\n\x05\x04\x01\x02\ + \x02\x05\x12\x04\x90\x01\x02\x06\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\ + \x90\x01\x07\x14\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\x90\x01\x17\x18\n\ + \xbb\x02\n\x04\x04\x01\x02\x03\x12\x04\x97\x01\x02\x19\x1a\xac\x02\x20St\ + reaming\x20calls\x20might\x20be\x20interrupted\x20for\x20a\x20variety\ + \x20of\x20reasons,\x20such\n\x20as\x20TCP\x20connection\x20loss.\x20If\ + \x20this\x20occurs,\x20the\x20stream\x20of\x20results\x20can\n\x20be\x20\ + resumed\x20by\x20re-sending\x20the\x20original\x20request\x20and\x20incl\ + uding\n\x20`resume_token`.\x20Note\x20that\x20executing\x20any\x20other\ + \x20transaction\x20in\x20the\n\x20same\x20session\x20invalidates\x20the\ + \x20token.\n\n\x0f\n\x05\x04\x01\x02\x03\x04\x12\x06\x97\x01\x02\x90\x01\ + \x19\n\r\n\x05\x04\x01\x02\x03\x05\x12\x04\x97\x01\x02\x07\n\r\n\x05\x04\ + \x01\x02\x03\x01\x12\x04\x97\x01\x08\x14\n\r\n\x05\x04\x01\x02\x03\x03\ + \x12\x04\x97\x01\x17\x18\n\xeb\x02\n\x04\x04\x01\x02\x04\x12\x04\x9f\x01\ + \x02\x1b\x1a\xdc\x02\x20Query\x20plan\x20and\x20execution\x20statistics\ + \x20for\x20the\x20statement\x20that\x20produced\x20this\n\x20streaming\ + \x20result\x20set.\x20These\x20can\x20be\x20requested\x20by\x20setting\n\ + \x20[ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.q\ + uery_mode]\x20and\x20are\x20sent\n\x20only\x20once\x20with\x20the\x20las\ + t\x20response\x20in\x20the\x20stream.\n\x20This\x20field\x20will\x20also\ + \x20be\x20present\x20in\x20the\x20last\x20response\x20for\x20DML\n\x20st\ + atements.\n\n\x0f\n\x05\x04\x01\x02\x04\x04\x12\x06\x9f\x01\x02\x97\x01\ + \x19\n\r\n\x05\x04\x01\x02\x04\x06\x12\x04\x9f\x01\x02\x10\n\r\n\x05\x04\ + \x01\x02\x04\x01\x12\x04\x9f\x01\x11\x16\n\r\n\x05\x04\x01\x02\x04\x03\ + \x12\x04\x9f\x01\x19\x1a\n\x84\x01\n\x02\x04\x02\x12\x06\xa3\x01\0\xb1\ + \x01\x01\x1av\x20Metadata\x20about\x20a\x20[ResultSet][google.spanner.v1\ + .ResultSet]\x20or\x20[PartialResultSet][google.spanner.v1.PartialResultS\ + et].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xa3\x01\x08\x19\n\xd2\x02\n\x04\ + \x04\x02\x02\0\x12\x04\xac\x01\x02\x1a\x1a\xc3\x02\x20Indicates\x20the\ + \x20field\x20names\x20and\x20types\x20for\x20the\x20rows\x20in\x20the\ + \x20result\n\x20set.\x20\x20For\x20example,\x20a\x20SQL\x20query\x20like\ + \x20`\"SELECT\x20UserId,\x20UserName\x20FROM\n\x20Users\"`\x20could\x20r\ + eturn\x20a\x20`row_type`\x20value\x20like:\n\n\x20\x20\x20\x20\x20\"fiel\ + ds\":\x20[\n\x20\x20\x20\x20\x20\x20\x20{\x20\"name\":\x20\"UserId\",\ + \x20\"type\":\x20{\x20\"code\":\x20\"INT64\"\x20}\x20},\n\x20\x20\x20\ + \x20\x20\x20\x20{\x20\"name\":\x20\"UserName\",\x20\"type\":\x20{\x20\"c\ + ode\":\x20\"STRING\"\x20}\x20},\n\x20\x20\x20\x20\x20]\n\n\x0f\n\x05\x04\ + \x02\x02\0\x04\x12\x06\xac\x01\x02\xa3\x01\x1b\n\r\n\x05\x04\x02\x02\0\ + \x06\x12\x04\xac\x01\x02\x0c\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xac\x01\ + \r\x15\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\xac\x01\x18\x19\n\x8a\x01\n\ + \x04\x04\x02\x02\x01\x12\x04\xb0\x01\x02\x1e\x1a|\x20If\x20the\x20read\ + \x20or\x20SQL\x20query\x20began\x20a\x20transaction\x20as\x20a\x20side-e\ + ffect,\x20the\n\x20information\x20about\x20the\x20new\x20transaction\x20\ + is\x20yielded\x20here.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\x06\xb0\x01\ + \x02\xac\x01\x1a\n\r\n\x05\x04\x02\x02\x01\x06\x12\x04\xb0\x01\x02\r\n\r\ + \n\x05\x04\x02\x02\x01\x01\x12\x04\xb0\x01\x0e\x19\n\r\n\x05\x04\x02\x02\ + \x01\x03\x12\x04\xb0\x01\x1c\x1d\n\x92\x01\n\x02\x04\x03\x12\x06\xb4\x01\ + \0\xcc\x01\x01\x1a\x83\x01\x20Additional\x20statistics\x20about\x20a\x20\ + [ResultSet][google.spanner.v1.ResultSet]\x20or\x20[PartialResultSet][goo\ + gle.spanner.v1.PartialResultSet].\n\n\x0b\n\x03\x04\x03\x01\x12\x04\xb4\ + \x01\x08\x16\nc\n\x04\x04\x03\x02\0\x12\x04\xb6\x01\x02\x1b\x1aU\x20[Que\ + ryPlan][google.spanner.v1.QueryPlan]\x20for\x20the\x20query\x20associate\ + d\x20with\x20this\x20result.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xb6\ + \x01\x02\xb4\x01\x18\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\xb6\x01\x02\x0b\ + \n\r\n\x05\x04\x03\x02\0\x01\x12\x04\xb6\x01\x0c\x16\n\r\n\x05\x04\x03\ + \x02\0\x03\x12\x04\xb6\x01\x19\x1a\n\x9e\x02\n\x04\x04\x03\x02\x01\x12\ + \x04\xc1\x01\x02)\x1a\x8f\x02\x20Aggregated\x20statistics\x20from\x20the\ + \x20execution\x20of\x20the\x20query.\x20Only\x20present\x20when\n\x20the\ + \x20query\x20is\x20profiled.\x20For\x20example,\x20a\x20query\x20could\ + \x20return\x20the\x20statistics\x20as\n\x20follows:\n\n\x20\x20\x20\x20\ + \x20{\n\x20\x20\x20\x20\x20\x20\x20\"rows_returned\":\x20\"3\",\n\x20\ + \x20\x20\x20\x20\x20\x20\"elapsed_time\":\x20\"1.22\x20secs\",\n\x20\x20\ + \x20\x20\x20\x20\x20\"cpu_time\":\x20\"1.19\x20secs\"\n\x20\x20\x20\x20\ + \x20}\n\n\x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\xc1\x01\x02\xb6\x01\x1b\ + \n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\xc1\x01\x02\x18\n\r\n\x05\x04\x03\ + \x02\x01\x01\x12\x04\xc1\x01\x19$\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\ + \xc1\x01'(\nC\n\x04\x04\x03\x08\0\x12\x06\xc4\x01\x02\xcb\x01\x03\x1a3\ + \x20The\x20number\x20of\x20rows\x20modified\x20by\x20the\x20DML\x20state\ + ment.\n\n\r\n\x05\x04\x03\x08\0\x01\x12\x04\xc4\x01\x08\x11\nO\n\x04\x04\ + \x03\x02\x02\x12\x04\xc6\x01\x04\x1e\x1aA\x20Standard\x20DML\x20returns\ + \x20an\x20exact\x20count\x20of\x20rows\x20that\x20were\x20modified.\n\n\ + \r\n\x05\x04\x03\x02\x02\x05\x12\x04\xc6\x01\x04\t\n\r\n\x05\x04\x03\x02\ + \x02\x01\x12\x04\xc6\x01\n\x19\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xc6\ + \x01\x1c\x1d\ny\n\x04\x04\x03\x02\x03\x12\x04\xca\x01\x04$\x1ak\x20Parti\ + tioned\x20DML\x20does\x20not\x20offer\x20exactly-once\x20semantics,\x20s\ + o\x20it\n\x20returns\x20a\x20lower\x20bound\x20of\x20the\x20rows\x20modi\ + fied.\n\n\r\n\x05\x04\x03\x02\x03\x05\x12\x04\xca\x01\x04\t\n\r\n\x05\ + \x04\x03\x02\x03\x01\x12\x04\xca\x01\n\x1f\n\r\n\x05\x04\x03\x02\x03\x03\ + \x12\x04\xca\x01\"#b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner.rs new file mode 100644 index 00000000..4e3d0d71 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner.rs @@ -0,0 +1,5892 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/spanner.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct CreateSessionRequest { + // message fields + pub database: ::std::string::String, + pub session: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CreateSessionRequest { + fn default() -> &'a CreateSessionRequest { + ::default_instance() + } +} + +impl CreateSessionRequest { + pub fn new() -> CreateSessionRequest { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } + + // .google.spanner.v1.Session session = 2; + + + pub fn get_session(&self) -> &Session { + self.session.as_ref().unwrap_or_else(|| Session::default_instance()) + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + pub fn has_session(&self) -> bool { + self.session.is_some() + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: Session) { + self.session = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut Session { + if self.session.is_none() { + self.session.set_default(); + } + self.session.as_mut().unwrap() + } + + // Take field + pub fn take_session(&mut self) -> Session { + self.session.take().unwrap_or_else(|| Session::new()) + } +} + +impl ::protobuf::Message for CreateSessionRequest { + fn is_initialized(&self) -> bool { + for v in &self.session { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.session)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + if let Some(ref v) = self.session.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + if let Some(ref v) = self.session.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CreateSessionRequest { + CreateSessionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &CreateSessionRequest| { &m.database }, + |m: &mut CreateSessionRequest| { &mut m.database }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "session", + |m: &CreateSessionRequest| { &m.session }, + |m: &mut CreateSessionRequest| { &mut m.session }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CreateSessionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CreateSessionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CreateSessionRequest, + }; + unsafe { + instance.get(CreateSessionRequest::new) + } + } +} + +impl ::protobuf::Clear for CreateSessionRequest { + fn clear(&mut self) { + self.database.clear(); + self.session.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CreateSessionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CreateSessionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Session { + // message fields + pub name: ::std::string::String, + pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>, + pub create_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + pub approximate_last_use_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Session { + fn default() -> &'a Session { + ::default_instance() + } +} + +impl Session { + pub fn new() -> Session { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.spanner.v1.Session.LabelsEntry labels = 2; + + + pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> { + &self.labels + } + pub fn clear_labels(&mut self) { + self.labels.clear(); + } + + // Param is passed by value, moved + pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) { + self.labels = v; + } + + // Mutable pointer to the field. + pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> { + &mut self.labels + } + + // Take field + pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> { + ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new()) + } + + // .google.protobuf.Timestamp create_time = 3; + + + pub fn get_create_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.create_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_create_time(&mut self) { + self.create_time.clear(); + } + + pub fn has_create_time(&self) -> bool { + self.create_time.is_some() + } + + // Param is passed by value, moved + pub fn set_create_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.create_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_create_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.create_time.is_none() { + self.create_time.set_default(); + } + self.create_time.as_mut().unwrap() + } + + // Take field + pub fn take_create_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.create_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } + + // .google.protobuf.Timestamp approximate_last_use_time = 4; + + + pub fn get_approximate_last_use_time(&self) -> &::protobuf::well_known_types::Timestamp { + self.approximate_last_use_time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_approximate_last_use_time(&mut self) { + self.approximate_last_use_time.clear(); + } + + pub fn has_approximate_last_use_time(&self) -> bool { + self.approximate_last_use_time.is_some() + } + + // Param is passed by value, moved + pub fn set_approximate_last_use_time(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.approximate_last_use_time = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_approximate_last_use_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.approximate_last_use_time.is_none() { + self.approximate_last_use_time.set_default(); + } + self.approximate_last_use_time.as_mut().unwrap() + } + + // Take field + pub fn take_approximate_last_use_time(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.approximate_last_use_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for Session { + fn is_initialized(&self) -> bool { + for v in &self.create_time { + if !v.is_initialized() { + return false; + } + }; + for v in &self.approximate_last_use_time { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_time)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.approximate_last_use_time)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels); + if let Some(ref v) = self.create_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.approximate_last_use_time.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels, os)?; + if let Some(ref v) = self.create_time.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.approximate_last_use_time.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Session { + Session::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Session| { &m.name }, + |m: &mut Session| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>( + "labels", + |m: &Session| { &m.labels }, + |m: &mut Session| { &mut m.labels }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "create_time", + |m: &Session| { &m.create_time }, + |m: &mut Session| { &mut m.create_time }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "approximate_last_use_time", + |m: &Session| { &m.approximate_last_use_time }, + |m: &mut Session| { &mut m.approximate_last_use_time }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Session", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Session { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Session, + }; + unsafe { + instance.get(Session::new) + } + } +} + +impl ::protobuf::Clear for Session { + fn clear(&mut self) { + self.name.clear(); + self.labels.clear(); + self.create_time.clear(); + self.approximate_last_use_time.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Session { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Session { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct GetSessionRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GetSessionRequest { + fn default() -> &'a GetSessionRequest { + ::default_instance() + } +} + +impl GetSessionRequest { + pub fn new() -> GetSessionRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for GetSessionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GetSessionRequest { + GetSessionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &GetSessionRequest| { &m.name }, + |m: &mut GetSessionRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "GetSessionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GetSessionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const GetSessionRequest, + }; + unsafe { + instance.get(GetSessionRequest::new) + } + } +} + +impl ::protobuf::Clear for GetSessionRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GetSessionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GetSessionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSessionsRequest { + // message fields + pub database: ::std::string::String, + pub page_size: i32, + pub page_token: ::std::string::String, + pub filter: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSessionsRequest { + fn default() -> &'a ListSessionsRequest { + ::default_instance() + } +} + +impl ListSessionsRequest { + pub fn new() -> ListSessionsRequest { + ::std::default::Default::default() + } + + // string database = 1; + + + pub fn get_database(&self) -> &str { + &self.database + } + pub fn clear_database(&mut self) { + self.database.clear(); + } + + // Param is passed by value, moved + pub fn set_database(&mut self, v: ::std::string::String) { + self.database = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_database(&mut self) -> &mut ::std::string::String { + &mut self.database + } + + // Take field + pub fn take_database(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.database, ::std::string::String::new()) + } + + // int32 page_size = 2; + + + pub fn get_page_size(&self) -> i32 { + self.page_size + } + pub fn clear_page_size(&mut self) { + self.page_size = 0; + } + + // Param is passed by value, moved + pub fn set_page_size(&mut self, v: i32) { + self.page_size = v; + } + + // string page_token = 3; + + + pub fn get_page_token(&self) -> &str { + &self.page_token + } + pub fn clear_page_token(&mut self) { + self.page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_page_token(&mut self, v: ::std::string::String) { + self.page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_page_token(&mut self) -> &mut ::std::string::String { + &mut self.page_token + } + + // Take field + pub fn take_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.page_token, ::std::string::String::new()) + } + + // string filter = 4; + + + pub fn get_filter(&self) -> &str { + &self.filter + } + pub fn clear_filter(&mut self) { + self.filter.clear(); + } + + // Param is passed by value, moved + pub fn set_filter(&mut self, v: ::std::string::String) { + self.filter = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_filter(&mut self) -> &mut ::std::string::String { + &mut self.filter + } + + // Take field + pub fn take_filter(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.filter, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSessionsRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.page_size = tmp; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filter)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.database.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.database); + } + if self.page_size != 0 { + my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint); + } + if !self.page_token.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.page_token); + } + if !self.filter.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.filter); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.database.is_empty() { + os.write_string(1, &self.database)?; + } + if self.page_size != 0 { + os.write_int32(2, self.page_size)?; + } + if !self.page_token.is_empty() { + os.write_string(3, &self.page_token)?; + } + if !self.filter.is_empty() { + os.write_string(4, &self.filter)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSessionsRequest { + ListSessionsRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "database", + |m: &ListSessionsRequest| { &m.database }, + |m: &mut ListSessionsRequest| { &mut m.database }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "page_size", + |m: &ListSessionsRequest| { &m.page_size }, + |m: &mut ListSessionsRequest| { &mut m.page_size }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "page_token", + |m: &ListSessionsRequest| { &m.page_token }, + |m: &mut ListSessionsRequest| { &mut m.page_token }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "filter", + |m: &ListSessionsRequest| { &m.filter }, + |m: &mut ListSessionsRequest| { &mut m.filter }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSessionsRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSessionsRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSessionsRequest, + }; + unsafe { + instance.get(ListSessionsRequest::new) + } + } +} + +impl ::protobuf::Clear for ListSessionsRequest { + fn clear(&mut self) { + self.database.clear(); + self.page_size = 0; + self.page_token.clear(); + self.filter.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSessionsRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSessionsRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ListSessionsResponse { + // message fields + pub sessions: ::protobuf::RepeatedField, + pub next_page_token: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListSessionsResponse { + fn default() -> &'a ListSessionsResponse { + ::default_instance() + } +} + +impl ListSessionsResponse { + pub fn new() -> ListSessionsResponse { + ::std::default::Default::default() + } + + // repeated .google.spanner.v1.Session sessions = 1; + + + pub fn get_sessions(&self) -> &[Session] { + &self.sessions + } + pub fn clear_sessions(&mut self) { + self.sessions.clear(); + } + + // Param is passed by value, moved + pub fn set_sessions(&mut self, v: ::protobuf::RepeatedField) { + self.sessions = v; + } + + // Mutable pointer to the field. + pub fn mut_sessions(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.sessions + } + + // Take field + pub fn take_sessions(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.sessions, ::protobuf::RepeatedField::new()) + } + + // string next_page_token = 2; + + + pub fn get_next_page_token(&self) -> &str { + &self.next_page_token + } + pub fn clear_next_page_token(&mut self) { + self.next_page_token.clear(); + } + + // Param is passed by value, moved + pub fn set_next_page_token(&mut self, v: ::std::string::String) { + self.next_page_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String { + &mut self.next_page_token + } + + // Take field + pub fn take_next_page_token(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for ListSessionsResponse { + fn is_initialized(&self) -> bool { + for v in &self.sessions { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sessions)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.sessions { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.next_page_token.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.next_page_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.sessions { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.next_page_token.is_empty() { + os.write_string(2, &self.next_page_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListSessionsResponse { + ListSessionsResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "sessions", + |m: &ListSessionsResponse| { &m.sessions }, + |m: &mut ListSessionsResponse| { &mut m.sessions }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "next_page_token", + |m: &ListSessionsResponse| { &m.next_page_token }, + |m: &mut ListSessionsResponse| { &mut m.next_page_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ListSessionsResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListSessionsResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ListSessionsResponse, + }; + unsafe { + instance.get(ListSessionsResponse::new) + } + } +} + +impl ::protobuf::Clear for ListSessionsResponse { + fn clear(&mut self) { + self.sessions.clear(); + self.next_page_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListSessionsResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListSessionsResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct DeleteSessionRequest { + // message fields + pub name: ::std::string::String, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DeleteSessionRequest { + fn default() -> &'a DeleteSessionRequest { + ::default_instance() + } +} + +impl DeleteSessionRequest { + pub fn new() -> DeleteSessionRequest { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for DeleteSessionRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DeleteSessionRequest { + DeleteSessionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DeleteSessionRequest| { &m.name }, + |m: &mut DeleteSessionRequest| { &mut m.name }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "DeleteSessionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DeleteSessionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const DeleteSessionRequest, + }; + unsafe { + instance.get(DeleteSessionRequest::new) + } + } +} + +impl ::protobuf::Clear for DeleteSessionRequest { + fn clear(&mut self) { + self.name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DeleteSessionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DeleteSessionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ExecuteSqlRequest { + // message fields + pub session: ::std::string::String, + pub transaction: ::protobuf::SingularPtrField, + pub sql: ::std::string::String, + pub params: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>, + pub param_types: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>, + pub resume_token: ::std::vec::Vec, + pub query_mode: ExecuteSqlRequest_QueryMode, + pub partition_token: ::std::vec::Vec, + pub seqno: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ExecuteSqlRequest { + fn default() -> &'a ExecuteSqlRequest { + ::default_instance() + } +} + +impl ExecuteSqlRequest { + pub fn new() -> ExecuteSqlRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // .google.spanner.v1.TransactionSelector transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::TransactionSelector { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::TransactionSelector::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector { + self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new()) + } + + // string sql = 3; + + + pub fn get_sql(&self) -> &str { + &self.sql + } + pub fn clear_sql(&mut self) { + self.sql.clear(); + } + + // Param is passed by value, moved + pub fn set_sql(&mut self, v: ::std::string::String) { + self.sql = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_sql(&mut self) -> &mut ::std::string::String { + &mut self.sql + } + + // Take field + pub fn take_sql(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.sql, ::std::string::String::new()) + } + + // .google.protobuf.Struct params = 4; + + + pub fn get_params(&self) -> &::protobuf::well_known_types::Struct { + self.params.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance()) + } + pub fn clear_params(&mut self) { + self.params.clear(); + } + + pub fn has_params(&self) -> bool { + self.params.is_some() + } + + // Param is passed by value, moved + pub fn set_params(&mut self, v: ::protobuf::well_known_types::Struct) { + self.params = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_params(&mut self) -> &mut ::protobuf::well_known_types::Struct { + if self.params.is_none() { + self.params.set_default(); + } + self.params.as_mut().unwrap() + } + + // Take field + pub fn take_params(&mut self) -> ::protobuf::well_known_types::Struct { + self.params.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new()) + } + + // repeated .google.spanner.v1.ExecuteSqlRequest.ParamTypesEntry param_types = 5; + + + pub fn get_param_types(&self) -> &::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + &self.param_types + } + pub fn clear_param_types(&mut self) { + self.param_types.clear(); + } + + // Param is passed by value, moved + pub fn set_param_types(&mut self, v: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>) { + self.param_types = v; + } + + // Mutable pointer to the field. + pub fn mut_param_types(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + &mut self.param_types + } + + // Take field + pub fn take_param_types(&mut self) -> ::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + ::std::mem::replace(&mut self.param_types, ::std::collections::HashMap::new()) + } + + // bytes resume_token = 6; + + + pub fn get_resume_token(&self) -> &[u8] { + &self.resume_token + } + pub fn clear_resume_token(&mut self) { + self.resume_token.clear(); + } + + // Param is passed by value, moved + pub fn set_resume_token(&mut self, v: ::std::vec::Vec) { + self.resume_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resume_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.resume_token + } + + // Take field + pub fn take_resume_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.resume_token, ::std::vec::Vec::new()) + } + + // .google.spanner.v1.ExecuteSqlRequest.QueryMode query_mode = 7; + + + pub fn get_query_mode(&self) -> ExecuteSqlRequest_QueryMode { + self.query_mode + } + pub fn clear_query_mode(&mut self) { + self.query_mode = ExecuteSqlRequest_QueryMode::NORMAL; + } + + // Param is passed by value, moved + pub fn set_query_mode(&mut self, v: ExecuteSqlRequest_QueryMode) { + self.query_mode = v; + } + + // bytes partition_token = 8; + + + pub fn get_partition_token(&self) -> &[u8] { + &self.partition_token + } + pub fn clear_partition_token(&mut self) { + self.partition_token.clear(); + } + + // Param is passed by value, moved + pub fn set_partition_token(&mut self, v: ::std::vec::Vec) { + self.partition_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.partition_token + } + + // Take field + pub fn take_partition_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new()) + } + + // int64 seqno = 9; + + + pub fn get_seqno(&self) -> i64 { + self.seqno + } + pub fn clear_seqno(&mut self) { + self.seqno = 0; + } + + // Param is passed by value, moved + pub fn set_seqno(&mut self, v: i64) { + self.seqno = v; + } +} + +impl ::protobuf::Message for ExecuteSqlRequest { + fn is_initialized(&self) -> bool { + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + for v in &self.params { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.sql)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.params)?; + }, + 5 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.param_types)?; + }, + 6 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?; + }, + 7 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.query_mode, 7, &mut self.unknown_fields)? + }, + 8 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?; + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.seqno = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.sql.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.sql); + } + if let Some(ref v) = self.params.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(5, &self.param_types); + if !self.resume_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(6, &self.resume_token); + } + if self.query_mode != ExecuteSqlRequest_QueryMode::NORMAL { + my_size += ::protobuf::rt::enum_size(7, self.query_mode); + } + if !self.partition_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(8, &self.partition_token); + } + if self.seqno != 0 { + my_size += ::protobuf::rt::value_size(9, self.seqno, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.sql.is_empty() { + os.write_string(3, &self.sql)?; + } + if let Some(ref v) = self.params.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(5, &self.param_types, os)?; + if !self.resume_token.is_empty() { + os.write_bytes(6, &self.resume_token)?; + } + if self.query_mode != ExecuteSqlRequest_QueryMode::NORMAL { + os.write_enum(7, self.query_mode.value())?; + } + if !self.partition_token.is_empty() { + os.write_bytes(8, &self.partition_token)?; + } + if self.seqno != 0 { + os.write_int64(9, self.seqno)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ExecuteSqlRequest { + ExecuteSqlRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &ExecuteSqlRequest| { &m.session }, + |m: &mut ExecuteSqlRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &ExecuteSqlRequest| { &m.transaction }, + |m: &mut ExecuteSqlRequest| { &mut m.transaction }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "sql", + |m: &ExecuteSqlRequest| { &m.sql }, + |m: &mut ExecuteSqlRequest| { &mut m.sql }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>( + "params", + |m: &ExecuteSqlRequest| { &m.params }, + |m: &mut ExecuteSqlRequest| { &mut m.params }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "param_types", + |m: &ExecuteSqlRequest| { &m.param_types }, + |m: &mut ExecuteSqlRequest| { &mut m.param_types }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "resume_token", + |m: &ExecuteSqlRequest| { &m.resume_token }, + |m: &mut ExecuteSqlRequest| { &mut m.resume_token }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "query_mode", + |m: &ExecuteSqlRequest| { &m.query_mode }, + |m: &mut ExecuteSqlRequest| { &mut m.query_mode }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "partition_token", + |m: &ExecuteSqlRequest| { &m.partition_token }, + |m: &mut ExecuteSqlRequest| { &mut m.partition_token }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "seqno", + |m: &ExecuteSqlRequest| { &m.seqno }, + |m: &mut ExecuteSqlRequest| { &mut m.seqno }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ExecuteSqlRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ExecuteSqlRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ExecuteSqlRequest, + }; + unsafe { + instance.get(ExecuteSqlRequest::new) + } + } +} + +impl ::protobuf::Clear for ExecuteSqlRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction.clear(); + self.sql.clear(); + self.params.clear(); + self.param_types.clear(); + self.resume_token.clear(); + self.query_mode = ExecuteSqlRequest_QueryMode::NORMAL; + self.partition_token.clear(); + self.seqno = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ExecuteSqlRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ExecuteSqlRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum ExecuteSqlRequest_QueryMode { + NORMAL = 0, + PLAN = 1, + PROFILE = 2, +} + +impl ::protobuf::ProtobufEnum for ExecuteSqlRequest_QueryMode { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::NORMAL), + 1 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::PLAN), + 2 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::PROFILE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [ExecuteSqlRequest_QueryMode] = &[ + ExecuteSqlRequest_QueryMode::NORMAL, + ExecuteSqlRequest_QueryMode::PLAN, + ExecuteSqlRequest_QueryMode::PROFILE, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("ExecuteSqlRequest_QueryMode", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for ExecuteSqlRequest_QueryMode { +} + +impl ::std::default::Default for ExecuteSqlRequest_QueryMode { + fn default() -> Self { + ExecuteSqlRequest_QueryMode::NORMAL + } +} + +impl ::protobuf::reflect::ProtobufValue for ExecuteSqlRequest_QueryMode { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartitionOptions { + // message fields + pub partition_size_bytes: i64, + pub max_partitions: i64, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartitionOptions { + fn default() -> &'a PartitionOptions { + ::default_instance() + } +} + +impl PartitionOptions { + pub fn new() -> PartitionOptions { + ::std::default::Default::default() + } + + // int64 partition_size_bytes = 1; + + + pub fn get_partition_size_bytes(&self) -> i64 { + self.partition_size_bytes + } + pub fn clear_partition_size_bytes(&mut self) { + self.partition_size_bytes = 0; + } + + // Param is passed by value, moved + pub fn set_partition_size_bytes(&mut self, v: i64) { + self.partition_size_bytes = v; + } + + // int64 max_partitions = 2; + + + pub fn get_max_partitions(&self) -> i64 { + self.max_partitions + } + pub fn clear_max_partitions(&mut self) { + self.max_partitions = 0; + } + + // Param is passed by value, moved + pub fn set_max_partitions(&mut self, v: i64) { + self.max_partitions = v; + } +} + +impl ::protobuf::Message for PartitionOptions { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.partition_size_bytes = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.max_partitions = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.partition_size_bytes != 0 { + my_size += ::protobuf::rt::value_size(1, self.partition_size_bytes, ::protobuf::wire_format::WireTypeVarint); + } + if self.max_partitions != 0 { + my_size += ::protobuf::rt::value_size(2, self.max_partitions, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.partition_size_bytes != 0 { + os.write_int64(1, self.partition_size_bytes)?; + } + if self.max_partitions != 0 { + os.write_int64(2, self.max_partitions)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartitionOptions { + PartitionOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "partition_size_bytes", + |m: &PartitionOptions| { &m.partition_size_bytes }, + |m: &mut PartitionOptions| { &mut m.partition_size_bytes }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "max_partitions", + |m: &PartitionOptions| { &m.max_partitions }, + |m: &mut PartitionOptions| { &mut m.max_partitions }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartitionOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartitionOptions { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartitionOptions, + }; + unsafe { + instance.get(PartitionOptions::new) + } + } +} + +impl ::protobuf::Clear for PartitionOptions { + fn clear(&mut self) { + self.partition_size_bytes = 0; + self.max_partitions = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartitionOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartitionOptions { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartitionQueryRequest { + // message fields + pub session: ::std::string::String, + pub transaction: ::protobuf::SingularPtrField, + pub sql: ::std::string::String, + pub params: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>, + pub param_types: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>, + pub partition_options: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartitionQueryRequest { + fn default() -> &'a PartitionQueryRequest { + ::default_instance() + } +} + +impl PartitionQueryRequest { + pub fn new() -> PartitionQueryRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // .google.spanner.v1.TransactionSelector transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::TransactionSelector { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::TransactionSelector::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector { + self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new()) + } + + // string sql = 3; + + + pub fn get_sql(&self) -> &str { + &self.sql + } + pub fn clear_sql(&mut self) { + self.sql.clear(); + } + + // Param is passed by value, moved + pub fn set_sql(&mut self, v: ::std::string::String) { + self.sql = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_sql(&mut self) -> &mut ::std::string::String { + &mut self.sql + } + + // Take field + pub fn take_sql(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.sql, ::std::string::String::new()) + } + + // .google.protobuf.Struct params = 4; + + + pub fn get_params(&self) -> &::protobuf::well_known_types::Struct { + self.params.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance()) + } + pub fn clear_params(&mut self) { + self.params.clear(); + } + + pub fn has_params(&self) -> bool { + self.params.is_some() + } + + // Param is passed by value, moved + pub fn set_params(&mut self, v: ::protobuf::well_known_types::Struct) { + self.params = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_params(&mut self) -> &mut ::protobuf::well_known_types::Struct { + if self.params.is_none() { + self.params.set_default(); + } + self.params.as_mut().unwrap() + } + + // Take field + pub fn take_params(&mut self) -> ::protobuf::well_known_types::Struct { + self.params.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new()) + } + + // repeated .google.spanner.v1.PartitionQueryRequest.ParamTypesEntry param_types = 5; + + + pub fn get_param_types(&self) -> &::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + &self.param_types + } + pub fn clear_param_types(&mut self) { + self.param_types.clear(); + } + + // Param is passed by value, moved + pub fn set_param_types(&mut self, v: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>) { + self.param_types = v; + } + + // Mutable pointer to the field. + pub fn mut_param_types(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + &mut self.param_types + } + + // Take field + pub fn take_param_types(&mut self) -> ::std::collections::HashMap<::std::string::String, super::type_pb::Type> { + ::std::mem::replace(&mut self.param_types, ::std::collections::HashMap::new()) + } + + // .google.spanner.v1.PartitionOptions partition_options = 6; + + + pub fn get_partition_options(&self) -> &PartitionOptions { + self.partition_options.as_ref().unwrap_or_else(|| PartitionOptions::default_instance()) + } + pub fn clear_partition_options(&mut self) { + self.partition_options.clear(); + } + + pub fn has_partition_options(&self) -> bool { + self.partition_options.is_some() + } + + // Param is passed by value, moved + pub fn set_partition_options(&mut self, v: PartitionOptions) { + self.partition_options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_partition_options(&mut self) -> &mut PartitionOptions { + if self.partition_options.is_none() { + self.partition_options.set_default(); + } + self.partition_options.as_mut().unwrap() + } + + // Take field + pub fn take_partition_options(&mut self) -> PartitionOptions { + self.partition_options.take().unwrap_or_else(|| PartitionOptions::new()) + } +} + +impl ::protobuf::Message for PartitionQueryRequest { + fn is_initialized(&self) -> bool { + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + for v in &self.params { + if !v.is_initialized() { + return false; + } + }; + for v in &self.partition_options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.sql)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.params)?; + }, + 5 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(wire_type, is, &mut self.param_types)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.partition_options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.sql.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.sql); + } + if let Some(ref v) = self.params.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(5, &self.param_types); + if let Some(ref v) = self.partition_options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.sql.is_empty() { + os.write_string(3, &self.sql)?; + } + if let Some(ref v) = self.params.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>(5, &self.param_types, os)?; + if let Some(ref v) = self.partition_options.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartitionQueryRequest { + PartitionQueryRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &PartitionQueryRequest| { &m.session }, + |m: &mut PartitionQueryRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &PartitionQueryRequest| { &m.transaction }, + |m: &mut PartitionQueryRequest| { &mut m.transaction }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "sql", + |m: &PartitionQueryRequest| { &m.sql }, + |m: &mut PartitionQueryRequest| { &mut m.sql }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>( + "params", + |m: &PartitionQueryRequest| { &m.params }, + |m: &mut PartitionQueryRequest| { &mut m.params }, + )); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage>( + "param_types", + |m: &PartitionQueryRequest| { &m.param_types }, + |m: &mut PartitionQueryRequest| { &mut m.param_types }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "partition_options", + |m: &PartitionQueryRequest| { &m.partition_options }, + |m: &mut PartitionQueryRequest| { &mut m.partition_options }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartitionQueryRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartitionQueryRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartitionQueryRequest, + }; + unsafe { + instance.get(PartitionQueryRequest::new) + } + } +} + +impl ::protobuf::Clear for PartitionQueryRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction.clear(); + self.sql.clear(); + self.params.clear(); + self.param_types.clear(); + self.partition_options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartitionQueryRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartitionQueryRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartitionReadRequest { + // message fields + pub session: ::std::string::String, + pub transaction: ::protobuf::SingularPtrField, + pub table: ::std::string::String, + pub index: ::std::string::String, + pub columns: ::protobuf::RepeatedField<::std::string::String>, + pub key_set: ::protobuf::SingularPtrField, + pub partition_options: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartitionReadRequest { + fn default() -> &'a PartitionReadRequest { + ::default_instance() + } +} + +impl PartitionReadRequest { + pub fn new() -> PartitionReadRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // .google.spanner.v1.TransactionSelector transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::TransactionSelector { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::TransactionSelector::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector { + self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new()) + } + + // string table = 3; + + + pub fn get_table(&self) -> &str { + &self.table + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: ::std::string::String) { + self.table = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut ::std::string::String { + &mut self.table + } + + // Take field + pub fn take_table(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table, ::std::string::String::new()) + } + + // string index = 4; + + + pub fn get_index(&self) -> &str { + &self.index + } + pub fn clear_index(&mut self) { + self.index.clear(); + } + + // Param is passed by value, moved + pub fn set_index(&mut self, v: ::std::string::String) { + self.index = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_index(&mut self) -> &mut ::std::string::String { + &mut self.index + } + + // Take field + pub fn take_index(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.index, ::std::string::String::new()) + } + + // repeated string columns = 5; + + + pub fn get_columns(&self) -> &[::std::string::String] { + &self.columns + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + + // Param is passed by value, moved + pub fn set_columns(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.columns = v; + } + + // Mutable pointer to the field. + pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.columns + } + + // Take field + pub fn take_columns(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new()) + } + + // .google.spanner.v1.KeySet key_set = 6; + + + pub fn get_key_set(&self) -> &super::keys::KeySet { + self.key_set.as_ref().unwrap_or_else(|| super::keys::KeySet::default_instance()) + } + pub fn clear_key_set(&mut self) { + self.key_set.clear(); + } + + pub fn has_key_set(&self) -> bool { + self.key_set.is_some() + } + + // Param is passed by value, moved + pub fn set_key_set(&mut self, v: super::keys::KeySet) { + self.key_set = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key_set(&mut self) -> &mut super::keys::KeySet { + if self.key_set.is_none() { + self.key_set.set_default(); + } + self.key_set.as_mut().unwrap() + } + + // Take field + pub fn take_key_set(&mut self) -> super::keys::KeySet { + self.key_set.take().unwrap_or_else(|| super::keys::KeySet::new()) + } + + // .google.spanner.v1.PartitionOptions partition_options = 9; + + + pub fn get_partition_options(&self) -> &PartitionOptions { + self.partition_options.as_ref().unwrap_or_else(|| PartitionOptions::default_instance()) + } + pub fn clear_partition_options(&mut self) { + self.partition_options.clear(); + } + + pub fn has_partition_options(&self) -> bool { + self.partition_options.is_some() + } + + // Param is passed by value, moved + pub fn set_partition_options(&mut self, v: PartitionOptions) { + self.partition_options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_partition_options(&mut self) -> &mut PartitionOptions { + if self.partition_options.is_none() { + self.partition_options.set_default(); + } + self.partition_options.as_mut().unwrap() + } + + // Take field + pub fn take_partition_options(&mut self) -> PartitionOptions { + self.partition_options.take().unwrap_or_else(|| PartitionOptions::new()) + } +} + +impl ::protobuf::Message for PartitionReadRequest { + fn is_initialized(&self) -> bool { + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + for v in &self.key_set { + if !v.is_initialized() { + return false; + } + }; + for v in &self.partition_options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.index)?; + }, + 5 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.columns)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key_set)?; + }, + 9 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.partition_options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.table.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.table); + } + if !self.index.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.index); + } + for value in &self.columns { + my_size += ::protobuf::rt::string_size(5, &value); + }; + if let Some(ref v) = self.key_set.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.partition_options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.table.is_empty() { + os.write_string(3, &self.table)?; + } + if !self.index.is_empty() { + os.write_string(4, &self.index)?; + } + for v in &self.columns { + os.write_string(5, &v)?; + }; + if let Some(ref v) = self.key_set.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.partition_options.as_ref() { + os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartitionReadRequest { + PartitionReadRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &PartitionReadRequest| { &m.session }, + |m: &mut PartitionReadRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &PartitionReadRequest| { &m.transaction }, + |m: &mut PartitionReadRequest| { &mut m.transaction }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table", + |m: &PartitionReadRequest| { &m.table }, + |m: &mut PartitionReadRequest| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "index", + |m: &PartitionReadRequest| { &m.index }, + |m: &mut PartitionReadRequest| { &mut m.index }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "columns", + |m: &PartitionReadRequest| { &m.columns }, + |m: &mut PartitionReadRequest| { &mut m.columns }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "key_set", + |m: &PartitionReadRequest| { &m.key_set }, + |m: &mut PartitionReadRequest| { &mut m.key_set }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "partition_options", + |m: &PartitionReadRequest| { &m.partition_options }, + |m: &mut PartitionReadRequest| { &mut m.partition_options }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartitionReadRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartitionReadRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartitionReadRequest, + }; + unsafe { + instance.get(PartitionReadRequest::new) + } + } +} + +impl ::protobuf::Clear for PartitionReadRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction.clear(); + self.table.clear(); + self.index.clear(); + self.columns.clear(); + self.key_set.clear(); + self.partition_options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartitionReadRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartitionReadRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Partition { + // message fields + pub partition_token: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Partition { + fn default() -> &'a Partition { + ::default_instance() + } +} + +impl Partition { + pub fn new() -> Partition { + ::std::default::Default::default() + } + + // bytes partition_token = 1; + + + pub fn get_partition_token(&self) -> &[u8] { + &self.partition_token + } + pub fn clear_partition_token(&mut self) { + self.partition_token.clear(); + } + + // Param is passed by value, moved + pub fn set_partition_token(&mut self, v: ::std::vec::Vec) { + self.partition_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.partition_token + } + + // Take field + pub fn take_partition_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for Partition { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.partition_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.partition_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.partition_token.is_empty() { + os.write_bytes(1, &self.partition_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Partition { + Partition::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "partition_token", + |m: &Partition| { &m.partition_token }, + |m: &mut Partition| { &mut m.partition_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Partition", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Partition { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Partition, + }; + unsafe { + instance.get(Partition::new) + } + } +} + +impl ::protobuf::Clear for Partition { + fn clear(&mut self) { + self.partition_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Partition { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Partition { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct PartitionResponse { + // message fields + pub partitions: ::protobuf::RepeatedField, + pub transaction: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a PartitionResponse { + fn default() -> &'a PartitionResponse { + ::default_instance() + } +} + +impl PartitionResponse { + pub fn new() -> PartitionResponse { + ::std::default::Default::default() + } + + // repeated .google.spanner.v1.Partition partitions = 1; + + + pub fn get_partitions(&self) -> &[Partition] { + &self.partitions + } + pub fn clear_partitions(&mut self) { + self.partitions.clear(); + } + + // Param is passed by value, moved + pub fn set_partitions(&mut self, v: ::protobuf::RepeatedField) { + self.partitions = v; + } + + // Mutable pointer to the field. + pub fn mut_partitions(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.partitions + } + + // Take field + pub fn take_partitions(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.partitions, ::protobuf::RepeatedField::new()) + } + + // .google.spanner.v1.Transaction transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::Transaction { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::Transaction::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::Transaction) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::Transaction { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::Transaction { + self.transaction.take().unwrap_or_else(|| super::transaction::Transaction::new()) + } +} + +impl ::protobuf::Message for PartitionResponse { + fn is_initialized(&self) -> bool { + for v in &self.partitions { + if !v.is_initialized() { + return false; + } + }; + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.partitions)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.partitions { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.partitions { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> PartitionResponse { + PartitionResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "partitions", + |m: &PartitionResponse| { &m.partitions }, + |m: &mut PartitionResponse| { &mut m.partitions }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &PartitionResponse| { &m.transaction }, + |m: &mut PartitionResponse| { &mut m.transaction }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "PartitionResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static PartitionResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const PartitionResponse, + }; + unsafe { + instance.get(PartitionResponse::new) + } + } +} + +impl ::protobuf::Clear for PartitionResponse { + fn clear(&mut self) { + self.partitions.clear(); + self.transaction.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for PartitionResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for PartitionResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct ReadRequest { + // message fields + pub session: ::std::string::String, + pub transaction: ::protobuf::SingularPtrField, + pub table: ::std::string::String, + pub index: ::std::string::String, + pub columns: ::protobuf::RepeatedField<::std::string::String>, + pub key_set: ::protobuf::SingularPtrField, + pub limit: i64, + pub resume_token: ::std::vec::Vec, + pub partition_token: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ReadRequest { + fn default() -> &'a ReadRequest { + ::default_instance() + } +} + +impl ReadRequest { + pub fn new() -> ReadRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // .google.spanner.v1.TransactionSelector transaction = 2; + + + pub fn get_transaction(&self) -> &super::transaction::TransactionSelector { + self.transaction.as_ref().unwrap_or_else(|| super::transaction::TransactionSelector::default_instance()) + } + pub fn clear_transaction(&mut self) { + self.transaction.clear(); + } + + pub fn has_transaction(&self) -> bool { + self.transaction.is_some() + } + + // Param is passed by value, moved + pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) { + self.transaction = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector { + if self.transaction.is_none() { + self.transaction.set_default(); + } + self.transaction.as_mut().unwrap() + } + + // Take field + pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector { + self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new()) + } + + // string table = 3; + + + pub fn get_table(&self) -> &str { + &self.table + } + pub fn clear_table(&mut self) { + self.table.clear(); + } + + // Param is passed by value, moved + pub fn set_table(&mut self, v: ::std::string::String) { + self.table = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_table(&mut self) -> &mut ::std::string::String { + &mut self.table + } + + // Take field + pub fn take_table(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.table, ::std::string::String::new()) + } + + // string index = 4; + + + pub fn get_index(&self) -> &str { + &self.index + } + pub fn clear_index(&mut self) { + self.index.clear(); + } + + // Param is passed by value, moved + pub fn set_index(&mut self, v: ::std::string::String) { + self.index = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_index(&mut self) -> &mut ::std::string::String { + &mut self.index + } + + // Take field + pub fn take_index(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.index, ::std::string::String::new()) + } + + // repeated string columns = 5; + + + pub fn get_columns(&self) -> &[::std::string::String] { + &self.columns + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + + // Param is passed by value, moved + pub fn set_columns(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.columns = v; + } + + // Mutable pointer to the field. + pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.columns + } + + // Take field + pub fn take_columns(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new()) + } + + // .google.spanner.v1.KeySet key_set = 6; + + + pub fn get_key_set(&self) -> &super::keys::KeySet { + self.key_set.as_ref().unwrap_or_else(|| super::keys::KeySet::default_instance()) + } + pub fn clear_key_set(&mut self) { + self.key_set.clear(); + } + + pub fn has_key_set(&self) -> bool { + self.key_set.is_some() + } + + // Param is passed by value, moved + pub fn set_key_set(&mut self, v: super::keys::KeySet) { + self.key_set = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key_set(&mut self) -> &mut super::keys::KeySet { + if self.key_set.is_none() { + self.key_set.set_default(); + } + self.key_set.as_mut().unwrap() + } + + // Take field + pub fn take_key_set(&mut self) -> super::keys::KeySet { + self.key_set.take().unwrap_or_else(|| super::keys::KeySet::new()) + } + + // int64 limit = 8; + + + pub fn get_limit(&self) -> i64 { + self.limit + } + pub fn clear_limit(&mut self) { + self.limit = 0; + } + + // Param is passed by value, moved + pub fn set_limit(&mut self, v: i64) { + self.limit = v; + } + + // bytes resume_token = 9; + + + pub fn get_resume_token(&self) -> &[u8] { + &self.resume_token + } + pub fn clear_resume_token(&mut self) { + self.resume_token.clear(); + } + + // Param is passed by value, moved + pub fn set_resume_token(&mut self, v: ::std::vec::Vec) { + self.resume_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_resume_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.resume_token + } + + // Take field + pub fn take_resume_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.resume_token, ::std::vec::Vec::new()) + } + + // bytes partition_token = 10; + + + pub fn get_partition_token(&self) -> &[u8] { + &self.partition_token + } + pub fn clear_partition_token(&mut self) { + self.partition_token.clear(); + } + + // Param is passed by value, moved + pub fn set_partition_token(&mut self, v: ::std::vec::Vec) { + self.partition_token = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec { + &mut self.partition_token + } + + // Take field + pub fn take_partition_token(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for ReadRequest { + fn is_initialized(&self) -> bool { + for v in &self.transaction { + if !v.is_initialized() { + return false; + } + }; + for v in &self.key_set { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?; + }, + 3 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.index)?; + }, + 5 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.columns)?; + }, + 6 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key_set)?; + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.limit = tmp; + }, + 9 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?; + }, + 10 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if let Some(ref v) = self.transaction.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if !self.table.is_empty() { + my_size += ::protobuf::rt::string_size(3, &self.table); + } + if !self.index.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.index); + } + for value in &self.columns { + my_size += ::protobuf::rt::string_size(5, &value); + }; + if let Some(ref v) = self.key_set.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.limit != 0 { + my_size += ::protobuf::rt::value_size(8, self.limit, ::protobuf::wire_format::WireTypeVarint); + } + if !self.resume_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(9, &self.resume_token); + } + if !self.partition_token.is_empty() { + my_size += ::protobuf::rt::bytes_size(10, &self.partition_token); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if let Some(ref v) = self.transaction.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if !self.table.is_empty() { + os.write_string(3, &self.table)?; + } + if !self.index.is_empty() { + os.write_string(4, &self.index)?; + } + for v in &self.columns { + os.write_string(5, &v)?; + }; + if let Some(ref v) = self.key_set.as_ref() { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.limit != 0 { + os.write_int64(8, self.limit)?; + } + if !self.resume_token.is_empty() { + os.write_bytes(9, &self.resume_token)?; + } + if !self.partition_token.is_empty() { + os.write_bytes(10, &self.partition_token)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ReadRequest { + ReadRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &ReadRequest| { &m.session }, + |m: &mut ReadRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "transaction", + |m: &ReadRequest| { &m.transaction }, + |m: &mut ReadRequest| { &mut m.transaction }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "table", + |m: &ReadRequest| { &m.table }, + |m: &mut ReadRequest| { &mut m.table }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "index", + |m: &ReadRequest| { &m.index }, + |m: &mut ReadRequest| { &mut m.index }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "columns", + |m: &ReadRequest| { &m.columns }, + |m: &mut ReadRequest| { &mut m.columns }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "key_set", + |m: &ReadRequest| { &m.key_set }, + |m: &mut ReadRequest| { &mut m.key_set }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "limit", + |m: &ReadRequest| { &m.limit }, + |m: &mut ReadRequest| { &mut m.limit }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "resume_token", + |m: &ReadRequest| { &m.resume_token }, + |m: &mut ReadRequest| { &mut m.resume_token }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "partition_token", + |m: &ReadRequest| { &m.partition_token }, + |m: &mut ReadRequest| { &mut m.partition_token }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "ReadRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ReadRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ReadRequest, + }; + unsafe { + instance.get(ReadRequest::new) + } + } +} + +impl ::protobuf::Clear for ReadRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction.clear(); + self.table.clear(); + self.index.clear(); + self.columns.clear(); + self.key_set.clear(); + self.limit = 0; + self.resume_token.clear(); + self.partition_token.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ReadRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ReadRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct BeginTransactionRequest { + // message fields + pub session: ::std::string::String, + pub options: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BeginTransactionRequest { + fn default() -> &'a BeginTransactionRequest { + ::default_instance() + } +} + +impl BeginTransactionRequest { + pub fn new() -> BeginTransactionRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // .google.spanner.v1.TransactionOptions options = 2; + + + pub fn get_options(&self) -> &super::transaction::TransactionOptions { + self.options.as_ref().unwrap_or_else(|| super::transaction::TransactionOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: super::transaction::TransactionOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut super::transaction::TransactionOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> super::transaction::TransactionOptions { + self.options.take().unwrap_or_else(|| super::transaction::TransactionOptions::new()) + } +} + +impl ::protobuf::Message for BeginTransactionRequest { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if let Some(ref v) = self.options.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BeginTransactionRequest { + BeginTransactionRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &BeginTransactionRequest| { &m.session }, + |m: &mut BeginTransactionRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "options", + |m: &BeginTransactionRequest| { &m.options }, + |m: &mut BeginTransactionRequest| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "BeginTransactionRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BeginTransactionRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const BeginTransactionRequest, + }; + unsafe { + instance.get(BeginTransactionRequest::new) + } + } +} + +impl ::protobuf::Clear for BeginTransactionRequest { + fn clear(&mut self) { + self.session.clear(); + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BeginTransactionRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BeginTransactionRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CommitRequest { + // message fields + pub session: ::std::string::String, + pub mutations: ::protobuf::RepeatedField, + // message oneof groups + pub transaction: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CommitRequest { + fn default() -> &'a CommitRequest { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum CommitRequest_oneof_transaction { + transaction_id(::std::vec::Vec), + single_use_transaction(super::transaction::TransactionOptions), +} + +impl CommitRequest { + pub fn new() -> CommitRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // bytes transaction_id = 2; + + + pub fn get_transaction_id(&self) -> &[u8] { + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(ref v)) => v, + _ => &[], + } + } + pub fn clear_transaction_id(&mut self) { + self.transaction = ::std::option::Option::None; + } + + pub fn has_transaction_id(&self) -> bool { + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_transaction_id(&mut self, v: ::std::vec::Vec) { + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(v)) + } + + // Mutable pointer to the field. + pub fn mut_transaction_id(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(_)) = self.transaction { + } else { + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(::std::vec::Vec::new())); + } + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_transaction_id(&mut self) -> ::std::vec::Vec { + if self.has_transaction_id() { + match self.transaction.take() { + ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.spanner.v1.TransactionOptions single_use_transaction = 3; + + + pub fn get_single_use_transaction(&self) -> &super::transaction::TransactionOptions { + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(ref v)) => v, + _ => super::transaction::TransactionOptions::default_instance(), + } + } + pub fn clear_single_use_transaction(&mut self) { + self.transaction = ::std::option::Option::None; + } + + pub fn has_single_use_transaction(&self) -> bool { + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_single_use_transaction(&mut self, v: super::transaction::TransactionOptions) { + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(v)) + } + + // Mutable pointer to the field. + pub fn mut_single_use_transaction(&mut self) -> &mut super::transaction::TransactionOptions { + if let ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(_)) = self.transaction { + } else { + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(super::transaction::TransactionOptions::new())); + } + match self.transaction { + ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_single_use_transaction(&mut self) -> super::transaction::TransactionOptions { + if self.has_single_use_transaction() { + match self.transaction.take() { + ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(v)) => v, + _ => panic!(), + } + } else { + super::transaction::TransactionOptions::new() + } + } + + // repeated .google.spanner.v1.Mutation mutations = 4; + + + pub fn get_mutations(&self) -> &[super::mutation::Mutation] { + &self.mutations + } + pub fn clear_mutations(&mut self) { + self.mutations.clear(); + } + + // Param is passed by value, moved + pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField) { + self.mutations = v; + } + + // Mutable pointer to the field. + pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.mutations + } + + // Take field + pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CommitRequest { + fn is_initialized(&self) -> bool { + if let Some(CommitRequest_oneof_transaction::single_use_transaction(ref v)) = self.transaction { + if !v.is_initialized() { + return false; + } + } + for v in &self.mutations { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(is.read_message()?)); + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + for value in &self.mutations { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let ::std::option::Option::Some(ref v) = self.transaction { + match v { + &CommitRequest_oneof_transaction::transaction_id(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &CommitRequest_oneof_transaction::single_use_transaction(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + for v in &self.mutations { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let ::std::option::Option::Some(ref v) = self.transaction { + match v { + &CommitRequest_oneof_transaction::transaction_id(ref v) => { + os.write_bytes(2, v)?; + }, + &CommitRequest_oneof_transaction::single_use_transaction(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CommitRequest { + CommitRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &CommitRequest| { &m.session }, + |m: &mut CommitRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "transaction_id", + CommitRequest::has_transaction_id, + CommitRequest::get_transaction_id, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::transaction::TransactionOptions>( + "single_use_transaction", + CommitRequest::has_single_use_transaction, + CommitRequest::get_single_use_transaction, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "mutations", + |m: &CommitRequest| { &m.mutations }, + |m: &mut CommitRequest| { &mut m.mutations }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CommitRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CommitRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CommitRequest, + }; + unsafe { + instance.get(CommitRequest::new) + } + } +} + +impl ::protobuf::Clear for CommitRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction = ::std::option::Option::None; + self.transaction = ::std::option::Option::None; + self.mutations.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CommitRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CommitRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct CommitResponse { + // message fields + pub commit_timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CommitResponse { + fn default() -> &'a CommitResponse { + ::default_instance() + } +} + +impl CommitResponse { + pub fn new() -> CommitResponse { + ::std::default::Default::default() + } + + // .google.protobuf.Timestamp commit_timestamp = 1; + + + pub fn get_commit_timestamp(&self) -> &::protobuf::well_known_types::Timestamp { + self.commit_timestamp.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_commit_timestamp(&mut self) { + self.commit_timestamp.clear(); + } + + pub fn has_commit_timestamp(&self) -> bool { + self.commit_timestamp.is_some() + } + + // Param is passed by value, moved + pub fn set_commit_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.commit_timestamp = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_commit_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.commit_timestamp.is_none() { + self.commit_timestamp.set_default(); + } + self.commit_timestamp.as_mut().unwrap() + } + + // Take field + pub fn take_commit_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.commit_timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for CommitResponse { + fn is_initialized(&self) -> bool { + for v in &self.commit_timestamp { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.commit_timestamp)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.commit_timestamp.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.commit_timestamp.as_ref() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CommitResponse { + CommitResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "commit_timestamp", + |m: &CommitResponse| { &m.commit_timestamp }, + |m: &mut CommitResponse| { &mut m.commit_timestamp }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "CommitResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CommitResponse { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const CommitResponse, + }; + unsafe { + instance.get(CommitResponse::new) + } + } +} + +impl ::protobuf::Clear for CommitResponse { + fn clear(&mut self) { + self.commit_timestamp.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CommitResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CommitResponse { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct RollbackRequest { + // message fields + pub session: ::std::string::String, + pub transaction_id: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a RollbackRequest { + fn default() -> &'a RollbackRequest { + ::default_instance() + } +} + +impl RollbackRequest { + pub fn new() -> RollbackRequest { + ::std::default::Default::default() + } + + // string session = 1; + + + pub fn get_session(&self) -> &str { + &self.session + } + pub fn clear_session(&mut self) { + self.session.clear(); + } + + // Param is passed by value, moved + pub fn set_session(&mut self, v: ::std::string::String) { + self.session = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_session(&mut self) -> &mut ::std::string::String { + &mut self.session + } + + // Take field + pub fn take_session(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.session, ::std::string::String::new()) + } + + // bytes transaction_id = 2; + + + pub fn get_transaction_id(&self) -> &[u8] { + &self.transaction_id + } + pub fn clear_transaction_id(&mut self) { + self.transaction_id.clear(); + } + + // Param is passed by value, moved + pub fn set_transaction_id(&mut self, v: ::std::vec::Vec) { + self.transaction_id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_transaction_id(&mut self) -> &mut ::std::vec::Vec { + &mut self.transaction_id + } + + // Take field + pub fn take_transaction_id(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.transaction_id, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for RollbackRequest { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.transaction_id)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.session.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.session); + } + if !self.transaction_id.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.transaction_id); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.session.is_empty() { + os.write_string(1, &self.session)?; + } + if !self.transaction_id.is_empty() { + os.write_bytes(2, &self.transaction_id)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> RollbackRequest { + RollbackRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "session", + |m: &RollbackRequest| { &m.session }, + |m: &mut RollbackRequest| { &mut m.session }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "transaction_id", + |m: &RollbackRequest| { &m.transaction_id }, + |m: &mut RollbackRequest| { &mut m.transaction_id }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "RollbackRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static RollbackRequest { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const RollbackRequest, + }; + unsafe { + instance.get(RollbackRequest::new) + } + } +} + +impl ::protobuf::Clear for RollbackRequest { + fn clear(&mut self) { + self.session.clear(); + self.transaction_id.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for RollbackRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for RollbackRequest { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1fgoogle/spanner/v1/spanner.proto\x12\x11google.spanner.v1\x1a\x1cgo\ + ogle/api/annotations.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1cgoo\ + gle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1c\ + google/spanner/v1/keys.proto\x1a\x20google/spanner/v1/mutation.proto\x1a\ + \"google/spanner/v1/result_set.proto\x1a#google/spanner/v1/transaction.p\ + roto\x1a\x1cgoogle/spanner/v1/type.proto\"h\n\x14CreateSessionRequest\ + \x12\x1a\n\x08database\x18\x01\x20\x01(\tR\x08database\x124\n\x07session\ + \x18\x02\x20\x01(\x0b2\x1a.google.spanner.v1.SessionR\x07session\"\xac\ + \x02\n\x07Session\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12>\n\ + \x06labels\x18\x02\x20\x03(\x0b2&.google.spanner.v1.Session.LabelsEntryR\ + \x06labels\x12;\n\x0bcreate_time\x18\x03\x20\x01(\x0b2\x1a.google.protob\ + uf.TimestampR\ncreateTime\x12U\n\x19approximate_last_use_time\x18\x04\ + \x20\x01(\x0b2\x1a.google.protobuf.TimestampR\x16approximateLastUseTime\ + \x1a9\n\x0bLabelsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\ + \x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\"'\n\x11GetSessio\ + nRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\x85\x01\n\x13Li\ + stSessionsRequest\x12\x1a\n\x08database\x18\x01\x20\x01(\tR\x08database\ + \x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_\ + token\x18\x03\x20\x01(\tR\tpageToken\x12\x16\n\x06filter\x18\x04\x20\x01\ + (\tR\x06filter\"v\n\x14ListSessionsResponse\x126\n\x08sessions\x18\x01\ + \x20\x03(\x0b2\x1a.google.spanner.v1.SessionR\x08sessions\x12&\n\x0fnext\ + _page_token\x18\x02\x20\x01(\tR\rnextPageToken\"*\n\x14DeleteSessionRequ\ + est\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\xca\x04\n\x11Execute\ + SqlRequest\x12\x18\n\x07session\x18\x01\x20\x01(\tR\x07session\x12H\n\ + \x0btransaction\x18\x02\x20\x01(\x0b2&.google.spanner.v1.TransactionSele\ + ctorR\x0btransaction\x12\x10\n\x03sql\x18\x03\x20\x01(\tR\x03sql\x12/\n\ + \x06params\x18\x04\x20\x01(\x0b2\x17.google.protobuf.StructR\x06params\ + \x12U\n\x0bparam_types\x18\x05\x20\x03(\x0b24.google.spanner.v1.ExecuteS\ + qlRequest.ParamTypesEntryR\nparamTypes\x12!\n\x0cresume_token\x18\x06\ + \x20\x01(\x0cR\x0bresumeToken\x12M\n\nquery_mode\x18\x07\x20\x01(\x0e2..\ + google.spanner.v1.ExecuteSqlRequest.QueryModeR\tqueryMode\x12'\n\x0fpart\ + ition_token\x18\x08\x20\x01(\x0cR\x0epartitionToken\x12\x14\n\x05seqno\ + \x18\t\x20\x01(\x03R\x05seqno\x1aV\n\x0fParamTypesEntry\x12\x10\n\x03key\ + \x18\x01\x20\x01(\tR\x03key\x12-\n\x05value\x18\x02\x20\x01(\x0b2\x17.go\ + ogle.spanner.v1.TypeR\x05value:\x028\x01\".\n\tQueryMode\x12\n\n\x06NORM\ + AL\x10\0\x12\x08\n\x04PLAN\x10\x01\x12\x0b\n\x07PROFILE\x10\x02\"k\n\x10\ + PartitionOptions\x120\n\x14partition_size_bytes\x18\x01\x20\x01(\x03R\ + \x12partitionSizeBytes\x12%\n\x0emax_partitions\x18\x02\x20\x01(\x03R\rm\ + axPartitions\"\xc3\x03\n\x15PartitionQueryRequest\x12\x18\n\x07session\ + \x18\x01\x20\x01(\tR\x07session\x12H\n\x0btransaction\x18\x02\x20\x01(\ + \x0b2&.google.spanner.v1.TransactionSelectorR\x0btransaction\x12\x10\n\ + \x03sql\x18\x03\x20\x01(\tR\x03sql\x12/\n\x06params\x18\x04\x20\x01(\x0b\ + 2\x17.google.protobuf.StructR\x06params\x12Y\n\x0bparam_types\x18\x05\ + \x20\x03(\x0b28.google.spanner.v1.PartitionQueryRequest.ParamTypesEntryR\ + \nparamTypes\x12P\n\x11partition_options\x18\x06\x20\x01(\x0b2#.google.s\ + panner.v1.PartitionOptionsR\x10partitionOptions\x1aV\n\x0fParamTypesEntr\ + y\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12-\n\x05value\x18\x02\ + \x20\x01(\x0b2\x17.google.spanner.v1.TypeR\x05value:\x028\x01\"\xc6\x02\ + \n\x14PartitionReadRequest\x12\x18\n\x07session\x18\x01\x20\x01(\tR\x07s\ + ession\x12H\n\x0btransaction\x18\x02\x20\x01(\x0b2&.google.spanner.v1.Tr\ + ansactionSelectorR\x0btransaction\x12\x14\n\x05table\x18\x03\x20\x01(\tR\ + \x05table\x12\x14\n\x05index\x18\x04\x20\x01(\tR\x05index\x12\x18\n\x07c\ + olumns\x18\x05\x20\x03(\tR\x07columns\x122\n\x07key_set\x18\x06\x20\x01(\ + \x0b2\x19.google.spanner.v1.KeySetR\x06keySet\x12P\n\x11partition_option\ + s\x18\t\x20\x01(\x0b2#.google.spanner.v1.PartitionOptionsR\x10partitionO\ + ptions\"4\n\tPartition\x12'\n\x0fpartition_token\x18\x01\x20\x01(\x0cR\ + \x0epartitionToken\"\x93\x01\n\x11PartitionResponse\x12<\n\npartitions\ + \x18\x01\x20\x03(\x0b2\x1c.google.spanner.v1.PartitionR\npartitions\x12@\ + \n\x0btransaction\x18\x02\x20\x01(\x0b2\x1e.google.spanner.v1.Transactio\ + nR\x0btransaction\"\xcd\x02\n\x0bReadRequest\x12\x18\n\x07session\x18\ + \x01\x20\x01(\tR\x07session\x12H\n\x0btransaction\x18\x02\x20\x01(\x0b2&\ + .google.spanner.v1.TransactionSelectorR\x0btransaction\x12\x14\n\x05tabl\ + e\x18\x03\x20\x01(\tR\x05table\x12\x14\n\x05index\x18\x04\x20\x01(\tR\ + \x05index\x12\x18\n\x07columns\x18\x05\x20\x03(\tR\x07columns\x122\n\x07\ + key_set\x18\x06\x20\x01(\x0b2\x19.google.spanner.v1.KeySetR\x06keySet\ + \x12\x14\n\x05limit\x18\x08\x20\x01(\x03R\x05limit\x12!\n\x0cresume_toke\ + n\x18\t\x20\x01(\x0cR\x0bresumeToken\x12'\n\x0fpartition_token\x18\n\x20\ + \x01(\x0cR\x0epartitionToken\"t\n\x17BeginTransactionRequest\x12\x18\n\ + \x07session\x18\x01\x20\x01(\tR\x07session\x12?\n\x07options\x18\x02\x20\ + \x01(\x0b2%.google.spanner.v1.TransactionOptionsR\x07options\"\xfb\x01\n\ + \rCommitRequest\x12\x18\n\x07session\x18\x01\x20\x01(\tR\x07session\x12'\ + \n\x0etransaction_id\x18\x02\x20\x01(\x0cH\0R\rtransactionId\x12]\n\x16s\ + ingle_use_transaction\x18\x03\x20\x01(\x0b2%.google.spanner.v1.Transacti\ + onOptionsH\0R\x14singleUseTransaction\x129\n\tmutations\x18\x04\x20\x03(\ + \x0b2\x1b.google.spanner.v1.MutationR\tmutationsB\r\n\x0btransaction\"W\ + \n\x0eCommitResponse\x12E\n\x10commit_timestamp\x18\x01\x20\x01(\x0b2\ + \x1a.google.protobuf.TimestampR\x0fcommitTimestamp\"R\n\x0fRollbackReque\ + st\x12\x18\n\x07session\x18\x01\x20\x01(\tR\x07session\x12%\n\x0etransac\ + tion_id\x18\x02\x20\x01(\x0cR\rtransactionId2\x83\x11\n\x07Spanner\x12\ + \x9b\x01\n\rCreateSession\x12'.google.spanner.v1.CreateSessionRequest\ + \x1a\x1a.google.spanner.v1.Session\"E\x82\xd3\xe4\x93\x02?\":/v1/{databa\ + se=projects/*/instances/*/databases/*}/sessions:\x01*\x12\x90\x01\n\nGet\ + Session\x12$.google.spanner.v1.GetSessionRequest\x1a\x1a.google.spanner.\ + v1.Session\"@\x82\xd3\xe4\x93\x02:\x128/v1/{name=projects/*/instances/*/\ + databases/*/sessions/*}\x12\xa3\x01\n\x0cListSessions\x12&.google.spanne\ + r.v1.ListSessionsRequest\x1a'.google.spanner.v1.ListSessionsResponse\"B\ + \x82\xd3\xe4\x93\x02<\x12:/v1/{database=projects/*/instances/*/databases\ + /*}/sessions\x12\x92\x01\n\rDeleteSession\x12'.google.spanner.v1.DeleteS\ + essionRequest\x1a\x16.google.protobuf.Empty\"@\x82\xd3\xe4\x93\x02:*8/v1\ + /{name=projects/*/instances/*/databases/*/sessions/*}\x12\xa3\x01\n\nExe\ + cuteSql\x12$.google.spanner.v1.ExecuteSqlRequest\x1a\x1c.google.spanner.\ + v1.ResultSet\"Q\x82\xd3\xe4\x93\x02K\"F/v1/{session=projects/*/instances\ + /*/databases/*/sessions/*}:executeSql:\x01*\x12\xbe\x01\n\x13ExecuteStre\ + amingSql\x12$.google.spanner.v1.ExecuteSqlRequest\x1a#.google.spanner.v1\ + .PartialResultSet\"Z\x82\xd3\xe4\x93\x02T\"O/v1/{session=projects/*/inst\ + ances/*/databases/*/sessions/*}:executeStreamingSql:\x01*0\x01\x12\x91\ + \x01\n\x04Read\x12\x1e.google.spanner.v1.ReadRequest\x1a\x1c.google.span\ + ner.v1.ResultSet\"K\x82\xd3\xe4\x93\x02E\"@/v1/{session=projects/*/insta\ + nces/*/databases/*/sessions/*}:read:\x01*\x12\xac\x01\n\rStreamingRead\ + \x12\x1e.google.spanner.v1.ReadRequest\x1a#.google.spanner.v1.PartialRes\ + ultSet\"T\x82\xd3\xe4\x93\x02N\"I/v1/{session=projects/*/instances/*/dat\ + abases/*/sessions/*}:streamingRead:\x01*0\x01\x12\xb7\x01\n\x10BeginTran\ + saction\x12*.google.spanner.v1.BeginTransactionRequest\x1a\x1e.google.sp\ + anner.v1.Transaction\"W\x82\xd3\xe4\x93\x02Q\"L/v1/{session=projects/*/i\ + nstances/*/databases/*/sessions/*}:beginTransaction:\x01*\x12\x9c\x01\n\ + \x06Commit\x12\x20.google.spanner.v1.CommitRequest\x1a!.google.spanner.v\ + 1.CommitResponse\"M\x82\xd3\xe4\x93\x02G\"B/v1/{session=projects/*/insta\ + nces/*/databases/*/sessions/*}:commit:\x01*\x12\x97\x01\n\x08Rollback\ + \x12\".google.spanner.v1.RollbackRequest\x1a\x16.google.protobuf.Empty\"\ + O\x82\xd3\xe4\x93\x02I\"D/v1/{session=projects/*/instances/*/databases/*\ + /sessions/*}:rollback:\x01*\x12\xb7\x01\n\x0ePartitionQuery\x12(.google.\ + spanner.v1.PartitionQueryRequest\x1a$.google.spanner.v1.PartitionRespons\ + e\"U\x82\xd3\xe4\x93\x02O\"J/v1/{session=projects/*/instances/*/database\ + s/*/sessions/*}:partitionQuery:\x01*\x12\xb4\x01\n\rPartitionRead\x12'.g\ + oogle.spanner.v1.PartitionReadRequest\x1a$.google.spanner.v1.PartitionRe\ + sponse\"T\x82\xd3\xe4\x93\x02N\"I/v1/{session=projects/*/instances/*/dat\ + abases/*/sessions/*}:partitionRead:\x01*B\x95\x01\n\x15com.google.spanne\ + r.v1B\x0cSpannerProtoP\x01Z8google.golang.org/genproto/googleapis/spanne\ + r/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V1\xca\x02\x17Google\\Cloud\ + \\Spanner\\V1J\xc8\xda\x01\n\x07\x12\x05\x0e\0\x84\x05\x01\n\xbc\x04\n\ + \x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202018\x20Google\x20LL\ + C\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.\ + 0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\ + \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\ + y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\ + \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\ + ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\ + \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\ + buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\ + \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\ + \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\ + guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\ + e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\n\t\n\x02\x03\0\x12\ + \x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0%\n\t\n\x02\x03\x02\x12\x03\ + \x14\0&\n\t\n\x02\x03\x03\x12\x03\x15\0)\n\t\n\x02\x03\x04\x12\x03\x16\0\ + &\n\t\n\x02\x03\x05\x12\x03\x17\0*\n\t\n\x02\x03\x06\x12\x03\x18\0,\n\t\ + \n\x02\x03\x07\x12\x03\x19\0-\n\t\n\x02\x03\x08\x12\x03\x1a\0&\n\x08\n\ + \x01\x08\x12\x03\x1c\04\n\t\n\x02\x08%\x12\x03\x1c\04\n\x08\n\x01\x08\ + \x12\x03\x1d\0O\n\t\n\x02\x08\x0b\x12\x03\x1d\0O\n\x08\n\x01\x08\x12\x03\ + \x1e\0\"\n\t\n\x02\x08\n\x12\x03\x1e\0\"\n\x08\n\x01\x08\x12\x03\x1f\0-\ + \n\t\n\x02\x08\x08\x12\x03\x1f\0-\n\x08\n\x01\x08\x12\x03\x20\0.\n\t\n\ + \x02\x08\x01\x12\x03\x20\0.\n\x08\n\x01\x08\x12\x03!\04\n\t\n\x02\x08)\ + \x12\x03!\04\n\x9d\x01\n\x02\x06\0\x12\x05(\0\xe6\x01\x01\x1a\x8f\x01\ + \x20Cloud\x20Spanner\x20API\n\n\x20The\x20Cloud\x20Spanner\x20API\x20can\ + \x20be\x20used\x20to\x20manage\x20sessions\x20and\x20execute\n\x20transa\ + ctions\x20on\x20data\x20stored\x20in\x20Cloud\x20Spanner\x20databases.\n\ + \n\n\n\x03\x06\0\x01\x12\x03(\x08\x0f\n\x8a\x07\n\x04\x06\0\x02\0\x12\ + \x04<\x02A\x03\x1a\xfb\x06\x20Creates\x20a\x20new\x20session.\x20A\x20se\ + ssion\x20can\x20be\x20used\x20to\x20perform\n\x20transactions\x20that\ + \x20read\x20and/or\x20modify\x20data\x20in\x20a\x20Cloud\x20Spanner\x20d\ + atabase.\n\x20Sessions\x20are\x20meant\x20to\x20be\x20reused\x20for\x20m\ + any\x20consecutive\n\x20transactions.\n\n\x20Sessions\x20can\x20only\x20\ + execute\x20one\x20transaction\x20at\x20a\x20time.\x20To\x20execute\n\x20\ + multiple\x20concurrent\x20read-write/write-only\x20transactions,\x20crea\ + te\n\x20multiple\x20sessions.\x20Note\x20that\x20standalone\x20reads\x20\ + and\x20queries\x20use\x20a\n\x20transaction\x20internally,\x20and\x20cou\ + nt\x20toward\x20the\x20one\x20transaction\n\x20limit.\n\n\x20Cloud\x20Sp\ + anner\x20limits\x20the\x20number\x20of\x20sessions\x20that\x20can\x20exi\ + st\x20at\x20any\x20given\n\x20time;\x20thus,\x20it\x20is\x20a\x20good\ + \x20idea\x20to\x20delete\x20idle\x20and/or\x20unneeded\x20sessions.\n\ + \x20Aside\x20from\x20explicit\x20deletes,\x20Cloud\x20Spanner\x20can\x20\ + delete\x20sessions\x20for\x20which\x20no\n\x20operations\x20are\x20sent\ + \x20for\x20more\x20than\x20an\x20hour.\x20If\x20a\x20session\x20is\x20de\ + leted,\n\x20requests\x20to\x20it\x20return\x20`NOT_FOUND`.\n\n\x20Idle\ + \x20sessions\x20can\x20be\x20kept\x20alive\x20by\x20sending\x20a\x20triv\ + ial\x20SQL\x20query\n\x20periodically,\x20e.g.,\x20`\"SELECT\x201\"`.\n\ + \n\x0c\n\x05\x06\0\x02\0\x01\x12\x03<\x06\x13\n\x0c\n\x05\x06\0\x02\0\ + \x02\x12\x03<\x14(\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03<3:\n\r\n\x05\x06\ + \0\x02\0\x04\x12\x04=\x04@\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\ + \x12\x04=\x04@\x06\n\x9d\x01\n\x04\x06\0\x02\x01\x12\x04F\x02J\x03\x1a\ + \x8e\x01\x20Gets\x20a\x20session.\x20Returns\x20`NOT_FOUND`\x20if\x20the\ + \x20session\x20does\x20not\x20exist.\n\x20This\x20is\x20mainly\x20useful\ + \x20for\x20determining\x20whether\x20a\x20session\x20is\x20still\n\x20al\ + ive.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03F\x06\x10\n\x0c\n\x05\x06\0\ + \x02\x01\x02\x12\x03F\x11\"\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03F-4\n\r\ + \n\x05\x06\0\x02\x01\x04\x12\x04G\x04I\x06\n\x11\n\t\x06\0\x02\x01\x04\ + \xb0\xca\xbc\"\x12\x04G\x04I\x06\n7\n\x04\x06\0\x02\x02\x12\x04M\x02Q\ + \x03\x1a)\x20Lists\x20all\x20sessions\x20in\x20a\x20given\x20database.\n\ + \n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03M\x06\x12\n\x0c\n\x05\x06\0\x02\ + \x02\x02\x12\x03M\x13&\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03M1E\n\r\n\ + \x05\x06\0\x02\x02\x04\x12\x04N\x04P\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\ + \xca\xbc\"\x12\x04N\x04P\x06\nN\n\x04\x06\0\x02\x03\x12\x04T\x02X\x03\ + \x1a@\x20Ends\x20a\x20session,\x20releasing\x20server\x20resources\x20as\ + sociated\x20with\x20it.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03T\x06\x13\ + \n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03T\x14(\n\x0c\n\x05\x06\0\x02\x03\ + \x03\x12\x03T3H\n\r\n\x05\x06\0\x02\x03\x04\x12\x04U\x04W\x06\n\x11\n\t\ + \x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04U\x04W\x06\n\xe9\x04\n\x04\x06\0\ + \x02\x04\x12\x04e\x02j\x03\x1a\xda\x04\x20Executes\x20an\x20SQL\x20state\ + ment,\x20returning\x20all\x20results\x20in\x20a\x20single\x20reply.\x20T\ + his\n\x20method\x20cannot\x20be\x20used\x20to\x20return\x20a\x20result\ + \x20set\x20larger\x20than\x2010\x20MiB;\n\x20if\x20the\x20query\x20yield\ + s\x20more\x20data\x20than\x20that,\x20the\x20query\x20fails\x20with\n\ + \x20a\x20`FAILED_PRECONDITION`\x20error.\n\n\x20Operations\x20inside\x20\ + read-write\x20transactions\x20might\x20return\x20`ABORTED`.\x20If\n\x20t\ + his\x20occurs,\x20the\x20application\x20should\x20restart\x20the\x20tran\ + saction\x20from\n\x20the\x20beginning.\x20See\x20[Transaction][google.sp\ + anner.v1.Transaction]\x20for\x20more\x20details.\n\n\x20Larger\x20result\ + \x20sets\x20can\x20be\x20fetched\x20in\x20streaming\x20fashion\x20by\x20\ + calling\n\x20[ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStre\ + amingSql]\x20instead.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03e\x06\x10\n\ + \x0c\n\x05\x06\0\x02\x04\x02\x12\x03e\x11\"\n\x0c\n\x05\x06\0\x02\x04\ + \x03\x12\x03e-6\n\r\n\x05\x06\0\x02\x04\x04\x12\x04f\x04i\x06\n\x11\n\t\ + \x06\0\x02\x04\x04\xb0\xca\xbc\"\x12\x04f\x04i\x06\n\xd5\x02\n\x04\x06\0\ + \x02\x05\x12\x04q\x02v\x03\x1a\xc6\x02\x20Like\x20[ExecuteSql][google.sp\ + anner.v1.Spanner.ExecuteSql],\x20except\x20returns\x20the\x20result\n\ + \x20set\x20as\x20a\x20stream.\x20Unlike\x20[ExecuteSql][google.spanner.v\ + 1.Spanner.ExecuteSql],\x20there\n\x20is\x20no\x20limit\x20on\x20the\x20s\ + ize\x20of\x20the\x20returned\x20result\x20set.\x20However,\x20no\n\x20in\ + dividual\x20row\x20in\x20the\x20result\x20set\x20can\x20exceed\x20100\ + \x20MiB,\x20and\x20no\n\x20column\x20value\x20can\x20exceed\x2010\x20MiB\ + .\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03q\x06\x19\n\x0c\n\x05\x06\0\x02\ + \x05\x02\x12\x03q\x1a+\n\x0c\n\x05\x06\0\x02\x05\x06\x12\x03q6<\n\x0c\n\ + \x05\x06\0\x02\x05\x03\x12\x03q=M\n\r\n\x05\x06\0\x02\x05\x04\x12\x04r\ + \x04u\x06\n\x11\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\"\x12\x04r\x04u\x06\n\ + \xb1\x05\n\x04\x06\0\x02\x06\x12\x06\x85\x01\x02\x8a\x01\x03\x1a\xa0\x05\ + \x20Reads\x20rows\x20from\x20the\x20database\x20using\x20key\x20lookups\ + \x20and\x20scans,\x20as\x20a\n\x20simple\x20key/value\x20style\x20altern\ + ative\x20to\n\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].\x20\ + \x20This\x20method\x20cannot\x20be\x20used\x20to\n\x20return\x20a\x20res\ + ult\x20set\x20larger\x20than\x2010\x20MiB;\x20if\x20the\x20read\x20match\ + es\x20more\n\x20data\x20than\x20that,\x20the\x20read\x20fails\x20with\ + \x20a\x20`FAILED_PRECONDITION`\n\x20error.\n\n\x20Reads\x20inside\x20rea\ + d-write\x20transactions\x20might\x20return\x20`ABORTED`.\x20If\n\x20this\ + \x20occurs,\x20the\x20application\x20should\x20restart\x20the\x20transac\ + tion\x20from\n\x20the\x20beginning.\x20See\x20[Transaction][google.spann\ + er.v1.Transaction]\x20for\x20more\x20details.\n\n\x20Larger\x20result\ + \x20sets\x20can\x20be\x20yielded\x20in\x20streaming\x20fashion\x20by\x20\ + calling\n\x20[StreamingRead][google.spanner.v1.Spanner.StreamingRead]\ + \x20instead.\n\n\r\n\x05\x06\0\x02\x06\x01\x12\x04\x85\x01\x06\n\n\r\n\ + \x05\x06\0\x02\x06\x02\x12\x04\x85\x01\x0b\x16\n\r\n\x05\x06\0\x02\x06\ + \x03\x12\x04\x85\x01!*\n\x0f\n\x05\x06\0\x02\x06\x04\x12\x06\x86\x01\x04\ + \x89\x01\x06\n\x13\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x06\x86\x01\ + \x04\x89\x01\x06\n\xbf\x02\n\x04\x06\0\x02\x07\x12\x06\x91\x01\x02\x96\ + \x01\x03\x1a\xae\x02\x20Like\x20[Read][google.spanner.v1.Spanner.Read],\ + \x20except\x20returns\x20the\x20result\x20set\x20as\x20a\n\x20stream.\ + \x20Unlike\x20[Read][google.spanner.v1.Spanner.Read],\x20there\x20is\x20\ + no\x20limit\x20on\x20the\n\x20size\x20of\x20the\x20returned\x20result\ + \x20set.\x20However,\x20no\x20individual\x20row\x20in\n\x20the\x20result\ + \x20set\x20can\x20exceed\x20100\x20MiB,\x20and\x20no\x20column\x20value\ + \x20can\x20exceed\n\x2010\x20MiB.\n\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\ + \x91\x01\x06\x13\n\r\n\x05\x06\0\x02\x07\x02\x12\x04\x91\x01\x14\x1f\n\r\ + \n\x05\x06\0\x02\x07\x06\x12\x04\x91\x01*0\n\r\n\x05\x06\0\x02\x07\x03\ + \x12\x04\x91\x011A\n\x0f\n\x05\x06\0\x02\x07\x04\x12\x06\x92\x01\x04\x95\ + \x01\x06\n\x13\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x06\x92\x01\x04\ + \x95\x01\x06\n\x87\x02\n\x04\x06\0\x02\x08\x12\x06\x9c\x01\x02\xa1\x01\ + \x03\x1a\xf6\x01\x20Begins\x20a\x20new\x20transaction.\x20This\x20step\ + \x20can\x20often\x20be\x20skipped:\n\x20[Read][google.spanner.v1.Spanner\ + .Read],\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]\x20and\n\ + \x20[Commit][google.spanner.v1.Spanner.Commit]\x20can\x20begin\x20a\x20n\ + ew\x20transaction\x20as\x20a\n\x20side-effect.\n\n\r\n\x05\x06\0\x02\x08\ + \x01\x12\x04\x9c\x01\x06\x16\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\x9c\x01\ + \x17.\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\x9c\x019D\n\x0f\n\x05\x06\0\ + \x02\x08\x04\x12\x06\x9d\x01\x04\xa0\x01\x06\n\x13\n\t\x06\0\x02\x08\x04\ + \xb0\xca\xbc\"\x12\x06\x9d\x01\x04\xa0\x01\x06\n\xb6\x03\n\x04\x06\0\x02\ + \t\x12\x06\xab\x01\x02\xb0\x01\x03\x1a\xa5\x03\x20Commits\x20a\x20transa\ + ction.\x20The\x20request\x20includes\x20the\x20mutations\x20to\x20be\n\ + \x20applied\x20to\x20rows\x20in\x20the\x20database.\n\n\x20`Commit`\x20m\ + ight\x20return\x20an\x20`ABORTED`\x20error.\x20This\x20can\x20occur\x20a\ + t\x20any\x20time;\n\x20commonly,\x20the\x20cause\x20is\x20conflicts\x20w\ + ith\x20concurrent\n\x20transactions.\x20However,\x20it\x20can\x20also\ + \x20happen\x20for\x20a\x20variety\x20of\x20other\n\x20reasons.\x20If\x20\ + `Commit`\x20returns\x20`ABORTED`,\x20the\x20caller\x20should\x20re-attem\ + pt\n\x20the\x20transaction\x20from\x20the\x20beginning,\x20re-using\x20t\ + he\x20same\x20session.\n\n\r\n\x05\x06\0\x02\t\x01\x12\x04\xab\x01\x06\ + \x0c\n\r\n\x05\x06\0\x02\t\x02\x12\x04\xab\x01\r\x1a\n\r\n\x05\x06\0\x02\ + \t\x03\x12\x04\xab\x01%3\n\x0f\n\x05\x06\0\x02\t\x04\x12\x06\xac\x01\x04\ + \xaf\x01\x06\n\x13\n\t\x06\0\x02\t\x04\xb0\xca\xbc\"\x12\x06\xac\x01\x04\ + \xaf\x01\x06\n\xd7\x03\n\x04\x06\0\x02\n\x12\x06\xba\x01\x02\xbf\x01\x03\ + \x1a\xc6\x03\x20Rolls\x20back\x20a\x20transaction,\x20releasing\x20any\ + \x20locks\x20it\x20holds.\x20It\x20is\x20a\x20good\n\x20idea\x20to\x20ca\ + ll\x20this\x20for\x20any\x20transaction\x20that\x20includes\x20one\x20or\ + \x20more\n\x20[Read][google.spanner.v1.Spanner.Read]\x20or\x20[ExecuteSq\ + l][google.spanner.v1.Spanner.ExecuteSql]\x20requests\x20and\n\x20ultimat\ + ely\x20decides\x20not\x20to\x20commit.\n\n\x20`Rollback`\x20returns\x20`\ + OK`\x20if\x20it\x20successfully\x20aborts\x20the\x20transaction,\x20the\ + \n\x20transaction\x20was\x20already\x20aborted,\x20or\x20the\x20transact\ + ion\x20is\x20not\n\x20found.\x20`Rollback`\x20never\x20returns\x20`ABORT\ + ED`.\n\n\r\n\x05\x06\0\x02\n\x01\x12\x04\xba\x01\x06\x0e\n\r\n\x05\x06\0\ + \x02\n\x02\x12\x04\xba\x01\x0f\x1e\n\r\n\x05\x06\0\x02\n\x03\x12\x04\xba\ + \x01)>\n\x0f\n\x05\x06\0\x02\n\x04\x12\x06\xbb\x01\x04\xbe\x01\x06\n\x13\ + \n\t\x06\0\x02\n\x04\xb0\xca\xbc\"\x12\x06\xbb\x01\x04\xbe\x01\x06\n\xef\ + \x05\n\x04\x06\0\x02\x0b\x12\x06\xcc\x01\x02\xd1\x01\x03\x1a\xde\x05\x20\ + Creates\x20a\x20set\x20of\x20partition\x20tokens\x20that\x20can\x20be\ + \x20used\x20to\x20execute\x20a\x20query\n\x20operation\x20in\x20parallel\ + .\x20\x20Each\x20of\x20the\x20returned\x20partition\x20tokens\x20can\x20\ + be\x20used\n\x20by\x20[ExecuteStreamingSql][google.spanner.v1.Spanner.Ex\ + ecuteStreamingSql]\x20to\x20specify\x20a\x20subset\n\x20of\x20the\x20que\ + ry\x20result\x20to\x20read.\x20\x20The\x20same\x20session\x20and\x20read\ + -only\x20transaction\n\x20must\x20be\x20used\x20by\x20the\x20PartitionQu\ + eryRequest\x20used\x20to\x20create\x20the\n\x20partition\x20tokens\x20an\ + d\x20the\x20ExecuteSqlRequests\x20that\x20use\x20the\x20partition\x20tok\ + ens.\n\n\x20Partition\x20tokens\x20become\x20invalid\x20when\x20the\x20s\ + ession\x20used\x20to\x20create\x20them\n\x20is\x20deleted,\x20is\x20idle\ + \x20for\x20too\x20long,\x20begins\x20a\x20new\x20transaction,\x20or\x20b\ + ecomes\x20too\n\x20old.\x20\x20When\x20any\x20of\x20these\x20happen,\x20\ + it\x20is\x20not\x20possible\x20to\x20resume\x20the\x20query,\x20and\n\ + \x20the\x20whole\x20operation\x20must\x20be\x20restarted\x20from\x20the\ + \x20beginning.\n\n\r\n\x05\x06\0\x02\x0b\x01\x12\x04\xcc\x01\x06\x14\n\r\ + \n\x05\x06\0\x02\x0b\x02\x12\x04\xcc\x01\x15*\n\r\n\x05\x06\0\x02\x0b\ + \x03\x12\x04\xcc\x015F\n\x0f\n\x05\x06\0\x02\x0b\x04\x12\x06\xcd\x01\x04\ + \xd0\x01\x06\n\x13\n\t\x06\0\x02\x0b\x04\xb0\xca\xbc\"\x12\x06\xcd\x01\ + \x04\xd0\x01\x06\n\x84\x07\n\x04\x06\0\x02\x0c\x12\x06\xe0\x01\x02\xe5\ + \x01\x03\x1a\xf3\x06\x20Creates\x20a\x20set\x20of\x20partition\x20tokens\ + \x20that\x20can\x20be\x20used\x20to\x20execute\x20a\x20read\n\x20operati\ + on\x20in\x20parallel.\x20\x20Each\x20of\x20the\x20returned\x20partition\ + \x20tokens\x20can\x20be\x20used\n\x20by\x20[StreamingRead][google.spanne\ + r.v1.Spanner.StreamingRead]\x20to\x20specify\x20a\x20subset\x20of\x20the\ + \x20read\n\x20result\x20to\x20read.\x20\x20The\x20same\x20session\x20and\ + \x20read-only\x20transaction\x20must\x20be\x20used\x20by\n\x20the\x20Par\ + titionReadRequest\x20used\x20to\x20create\x20the\x20partition\x20tokens\ + \x20and\x20the\n\x20ReadRequests\x20that\x20use\x20the\x20partition\x20t\ + okens.\x20\x20There\x20are\x20no\x20ordering\n\x20guarantees\x20on\x20ro\ + ws\x20returned\x20among\x20the\x20returned\x20partition\x20tokens,\x20or\ + \x20even\n\x20within\x20each\x20individual\x20StreamingRead\x20call\x20i\ + ssued\x20with\x20a\x20partition_token.\n\n\x20Partition\x20tokens\x20bec\ + ome\x20invalid\x20when\x20the\x20session\x20used\x20to\x20create\x20them\ + \n\x20is\x20deleted,\x20is\x20idle\x20for\x20too\x20long,\x20begins\x20a\ + \x20new\x20transaction,\x20or\x20becomes\x20too\n\x20old.\x20\x20When\ + \x20any\x20of\x20these\x20happen,\x20it\x20is\x20not\x20possible\x20to\ + \x20resume\x20the\x20read,\x20and\n\x20the\x20whole\x20operation\x20must\ + \x20be\x20restarted\x20from\x20the\x20beginning.\n\n\r\n\x05\x06\0\x02\ + \x0c\x01\x12\x04\xe0\x01\x06\x13\n\r\n\x05\x06\0\x02\x0c\x02\x12\x04\xe0\ + \x01\x14(\n\r\n\x05\x06\0\x02\x0c\x03\x12\x04\xe0\x013D\n\x0f\n\x05\x06\ + \0\x02\x0c\x04\x12\x06\xe1\x01\x04\xe4\x01\x06\n\x13\n\t\x06\0\x02\x0c\ + \x04\xb0\xca\xbc\"\x12\x06\xe1\x01\x04\xe4\x01\x06\nY\n\x02\x04\0\x12\ + \x06\xe9\x01\0\xef\x01\x01\x1aK\x20The\x20request\x20for\x20[CreateSessi\ + on][google.spanner.v1.Spanner.CreateSession].\n\n\x0b\n\x03\x04\0\x01\ + \x12\x04\xe9\x01\x08\x1c\nK\n\x04\x04\0\x02\0\x12\x04\xeb\x01\x02\x16\ + \x1a=\x20Required.\x20The\x20database\x20in\x20which\x20the\x20new\x20se\ + ssion\x20is\x20created.\n\n\x0f\n\x05\x04\0\x02\0\x04\x12\x06\xeb\x01\ + \x02\xe9\x01\x1e\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xeb\x01\x02\x08\n\r\n\ + \x05\x04\0\x02\0\x01\x12\x04\xeb\x01\t\x11\n\r\n\x05\x04\0\x02\0\x03\x12\ + \x04\xeb\x01\x14\x15\n&\n\x04\x04\0\x02\x01\x12\x04\xee\x01\x02\x16\x1a\ + \x18\x20The\x20session\x20to\x20create.\n\n\x0f\n\x05\x04\0\x02\x01\x04\ + \x12\x06\xee\x01\x02\xeb\x01\x16\n\r\n\x05\x04\0\x02\x01\x06\x12\x04\xee\ + \x01\x02\t\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\xee\x01\n\x11\n\r\n\x05\ + \x04\0\x02\x01\x03\x12\x04\xee\x01\x14\x15\n3\n\x02\x04\x01\x12\x06\xf2\ + \x01\0\x88\x02\x01\x1a%\x20A\x20session\x20in\x20the\x20Cloud\x20Spanner\ + \x20API.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xf2\x01\x08\x0f\n~\n\x04\x04\ + \x01\x02\0\x12\x04\xf5\x01\x02\x12\x1ap\x20The\x20name\x20of\x20the\x20s\ + ession.\x20This\x20is\x20always\x20system-assigned;\x20values\x20provide\ + d\n\x20when\x20creating\x20a\x20session\x20are\x20ignored.\n\n\x0f\n\x05\ + \x04\x01\x02\0\x04\x12\x06\xf5\x01\x02\xf2\x01\x11\n\r\n\x05\x04\x01\x02\ + \0\x05\x12\x04\xf5\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xf5\ + \x01\t\r\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xf5\x01\x10\x11\n\xd6\x03\n\ + \x04\x04\x01\x02\x01\x12\x04\x80\x02\x02!\x1a\xc7\x03\x20The\x20labels\ + \x20for\x20the\x20session.\n\n\x20\x20*\x20Label\x20keys\x20must\x20be\ + \x20between\x201\x20and\x2063\x20characters\x20long\x20and\x20must\x20co\ + nform\x20to\n\x20\x20\x20\x20the\x20following\x20regular\x20expression:\ + \x20`[a-z]([-a-z0-9]*[a-z0-9])?`.\n\x20\x20*\x20Label\x20values\x20must\ + \x20be\x20between\x200\x20and\x2063\x20characters\x20long\x20and\x20must\ + \x20conform\n\x20\x20\x20\x20to\x20the\x20regular\x20expression\x20`([a-\ + z]([-a-z0-9]*[a-z0-9])?)?`.\n\x20\x20*\x20No\x20more\x20than\x2064\x20la\ + bels\x20can\x20be\x20associated\x20with\x20a\x20given\x20session.\n\n\ + \x20See\x20https://goo.gl/xmQnxf\x20for\x20more\x20information\x20on\x20\ + and\x20examples\x20of\x20labels.\n\n\x0f\n\x05\x04\x01\x02\x01\x04\x12\ + \x06\x80\x02\x02\xf5\x01\x12\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\x80\ + \x02\x02\x15\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\x80\x02\x16\x1c\n\r\n\ + \x05\x04\x01\x02\x01\x03\x12\x04\x80\x02\x1f\x20\nG\n\x04\x04\x01\x02\ + \x02\x12\x04\x83\x02\x02,\x1a9\x20Output\x20only.\x20The\x20timestamp\ + \x20when\x20the\x20session\x20is\x20created.\n\n\x0f\n\x05\x04\x01\x02\ + \x02\x04\x12\x06\x83\x02\x02\x80\x02!\n\r\n\x05\x04\x01\x02\x02\x06\x12\ + \x04\x83\x02\x02\x1b\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\x83\x02\x1c'\ + \n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\x83\x02*+\n\x8d\x01\n\x04\x04\x01\ + \x02\x03\x12\x04\x87\x02\x02:\x1a\x7f\x20Output\x20only.\x20The\x20appro\ + ximate\x20timestamp\x20when\x20the\x20session\x20is\x20last\x20used.\x20\ + It\x20is\n\x20typically\x20earlier\x20than\x20the\x20actual\x20last\x20u\ + se\x20time.\n\n\x0f\n\x05\x04\x01\x02\x03\x04\x12\x06\x87\x02\x02\x83\ + \x02,\n\r\n\x05\x04\x01\x02\x03\x06\x12\x04\x87\x02\x02\x1b\n\r\n\x05\ + \x04\x01\x02\x03\x01\x12\x04\x87\x02\x1c5\n\r\n\x05\x04\x01\x02\x03\x03\ + \x12\x04\x87\x0289\nS\n\x02\x04\x02\x12\x06\x8b\x02\0\x8e\x02\x01\x1aE\ + \x20The\x20request\x20for\x20[GetSession][google.spanner.v1.Spanner.GetS\ + ession].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\x8b\x02\x08\x19\n>\n\x04\x04\ + \x02\x02\0\x12\x04\x8d\x02\x02\x12\x1a0\x20Required.\x20The\x20name\x20o\ + f\x20the\x20session\x20to\x20retrieve.\n\n\x0f\n\x05\x04\x02\x02\0\x04\ + \x12\x06\x8d\x02\x02\x8b\x02\x1b\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\x8d\ + \x02\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\x8d\x02\t\r\n\r\n\x05\ + \x04\x02\x02\0\x03\x12\x04\x8d\x02\x10\x11\nW\n\x02\x04\x03\x12\x06\x91\ + \x02\0\xa9\x02\x01\x1aI\x20The\x20request\x20for\x20[ListSessions][googl\ + e.spanner.v1.Spanner.ListSessions].\n\n\x0b\n\x03\x04\x03\x01\x12\x04\ + \x91\x02\x08\x1b\nA\n\x04\x04\x03\x02\0\x12\x04\x93\x02\x02\x16\x1a3\x20\ + Required.\x20The\x20database\x20in\x20which\x20to\x20list\x20sessions.\n\ + \n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\x93\x02\x02\x91\x02\x1d\n\r\n\x05\ + \x04\x03\x02\0\x05\x12\x04\x93\x02\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\ + \x12\x04\x93\x02\t\x11\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x93\x02\x14\ + \x15\n\x85\x01\n\x04\x04\x03\x02\x01\x12\x04\x97\x02\x02\x16\x1aw\x20Num\ + ber\x20of\x20sessions\x20to\x20be\x20returned\x20in\x20the\x20response.\ + \x20If\x200\x20or\x20less,\x20defaults\n\x20to\x20the\x20server's\x20max\ + imum\x20allowed\x20page\x20size.\n\n\x0f\n\x05\x04\x03\x02\x01\x04\x12\ + \x06\x97\x02\x02\x93\x02\x16\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\x97\ + \x02\x02\x07\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x97\x02\x08\x11\n\r\n\ + \x05\x04\x03\x02\x01\x03\x12\x04\x97\x02\x14\x15\n\xd8\x01\n\x04\x04\x03\ + \x02\x02\x12\x04\x9c\x02\x02\x18\x1a\xc9\x01\x20If\x20non-empty,\x20`pag\ + e_token`\x20should\x20contain\x20a\n\x20[next_page_token][google.spanner\ + .v1.ListSessionsResponse.next_page_token]\x20from\x20a\x20previous\n\x20\ + [ListSessionsResponse][google.spanner.v1.ListSessionsResponse].\n\n\x0f\ + \n\x05\x04\x03\x02\x02\x04\x12\x06\x9c\x02\x02\x97\x02\x16\n\r\n\x05\x04\ + \x03\x02\x02\x05\x12\x04\x9c\x02\x02\x08\n\r\n\x05\x04\x03\x02\x02\x01\ + \x12\x04\x9c\x02\t\x13\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\x9c\x02\x16\ + \x17\n\xaf\x03\n\x04\x04\x03\x02\x03\x12\x04\xa8\x02\x02\x14\x1a\xa0\x03\ + \x20An\x20expression\x20for\x20filtering\x20the\x20results\x20of\x20the\ + \x20request.\x20Filter\x20rules\x20are\n\x20case\x20insensitive.\x20The\ + \x20fields\x20eligible\x20for\x20filtering\x20are:\n\n\x20\x20\x20*\x20`\ + labels.key`\x20where\x20key\x20is\x20the\x20name\x20of\x20a\x20label\n\n\ + \x20Some\x20examples\x20of\x20using\x20filters\x20are:\n\n\x20\x20\x20*\ + \x20`labels.env:*`\x20-->\x20The\x20session\x20has\x20the\x20label\x20\"\ + env\".\n\x20\x20\x20*\x20`labels.env:dev`\x20-->\x20The\x20session\x20ha\ + s\x20the\x20label\x20\"env\"\x20and\x20the\x20value\x20of\n\x20\x20\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20the\x20label\x20contains\x20the\x20string\x20\"dev\".\n\n\ + \x0f\n\x05\x04\x03\x02\x03\x04\x12\x06\xa8\x02\x02\x9c\x02\x18\n\r\n\x05\ + \x04\x03\x02\x03\x05\x12\x04\xa8\x02\x02\x08\n\r\n\x05\x04\x03\x02\x03\ + \x01\x12\x04\xa8\x02\t\x0f\n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\xa8\x02\ + \x12\x13\nX\n\x02\x04\x04\x12\x06\xac\x02\0\xb4\x02\x01\x1aJ\x20The\x20r\ + esponse\x20for\x20[ListSessions][google.spanner.v1.Spanner.ListSessions]\ + .\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xac\x02\x08\x1c\n/\n\x04\x04\x04\x02\ + \0\x12\x04\xae\x02\x02\x20\x1a!\x20The\x20list\x20of\x20requested\x20ses\ + sions.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\xae\x02\x02\n\n\r\n\x05\x04\ + \x04\x02\0\x06\x12\x04\xae\x02\x0b\x12\n\r\n\x05\x04\x04\x02\0\x01\x12\ + \x04\xae\x02\x13\x1b\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xae\x02\x1e\x1f\ + \n\xa4\x01\n\x04\x04\x04\x02\x01\x12\x04\xb3\x02\x02\x1d\x1a\x95\x01\x20\ + `next_page_token`\x20can\x20be\x20sent\x20in\x20a\x20subsequent\n\x20[Li\ + stSessions][google.spanner.v1.Spanner.ListSessions]\x20call\x20to\x20fet\ + ch\x20more\x20of\x20the\x20matching\n\x20sessions.\n\n\x0f\n\x05\x04\x04\ + \x02\x01\x04\x12\x06\xb3\x02\x02\xae\x02\x20\n\r\n\x05\x04\x04\x02\x01\ + \x05\x12\x04\xb3\x02\x02\x08\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xb3\ + \x02\t\x18\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xb3\x02\x1b\x1c\nY\n\ + \x02\x04\x05\x12\x06\xb7\x02\0\xba\x02\x01\x1aK\x20The\x20request\x20for\ + \x20[DeleteSession][google.spanner.v1.Spanner.DeleteSession].\n\n\x0b\n\ + \x03\x04\x05\x01\x12\x04\xb7\x02\x08\x1c\n<\n\x04\x04\x05\x02\0\x12\x04\ + \xb9\x02\x02\x12\x1a.\x20Required.\x20The\x20name\x20of\x20the\x20sessio\ + n\x20to\x20delete.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\xb9\x02\x02\ + \xb7\x02\x1e\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xb9\x02\x02\x08\n\r\n\ + \x05\x04\x05\x02\0\x01\x12\x04\xb9\x02\t\r\n\r\n\x05\x04\x05\x02\0\x03\ + \x12\x04\xb9\x02\x10\x11\n\x9e\x01\n\x02\x04\x06\x12\x06\xbe\x02\0\x9a\ + \x03\x01\x1a\x8f\x01\x20The\x20request\x20for\x20[ExecuteSql][google.spa\ + nner.v1.Spanner.ExecuteSql]\x20and\n\x20[ExecuteStreamingSql][google.spa\ + nner.v1.Spanner.ExecuteStreamingSql].\n\n\x0b\n\x03\x04\x06\x01\x12\x04\ + \xbe\x02\x08\x19\n@\n\x04\x04\x06\x04\0\x12\x06\xc0\x02\x02\xcb\x02\x03\ + \x1a0\x20Mode\x20in\x20which\x20the\x20statement\x20must\x20be\x20proces\ + sed.\n\n\r\n\x05\x04\x06\x04\0\x01\x12\x04\xc0\x02\x07\x10\nL\n\x06\x04\ + \x06\x04\0\x02\0\x12\x04\xc2\x02\x04\x0f\x1a<\x20The\x20default\x20mode.\ + \x20Only\x20the\x20statement\x20results\x20are\x20returned.\n\n\x0f\n\ + \x07\x04\x06\x04\0\x02\0\x01\x12\x04\xc2\x02\x04\n\n\x0f\n\x07\x04\x06\ + \x04\0\x02\0\x02\x12\x04\xc2\x02\r\x0e\nr\n\x06\x04\x06\x04\0\x02\x01\ + \x12\x04\xc6\x02\x04\r\x1ab\x20This\x20mode\x20returns\x20only\x20the\ + \x20query\x20plan,\x20without\x20any\x20results\x20or\n\x20execution\x20\ + statistics\x20information.\n\n\x0f\n\x07\x04\x06\x04\0\x02\x01\x01\x12\ + \x04\xc6\x02\x04\x08\n\x0f\n\x07\x04\x06\x04\0\x02\x01\x02\x12\x04\xc6\ + \x02\x0b\x0c\nm\n\x06\x04\x06\x04\0\x02\x02\x12\x04\xca\x02\x04\x10\x1a]\ + \x20This\x20mode\x20returns\x20both\x20the\x20query\x20plan\x20and\x20th\ + e\x20execution\x20statistics\x20along\n\x20with\x20the\x20results.\n\n\ + \x0f\n\x07\x04\x06\x04\0\x02\x02\x01\x12\x04\xca\x02\x04\x0b\n\x0f\n\x07\ + \x04\x06\x04\0\x02\x02\x02\x12\x04\xca\x02\x0e\x0f\nQ\n\x04\x04\x06\x02\ + \0\x12\x04\xce\x02\x02\x15\x1aC\x20Required.\x20The\x20session\x20in\x20\ + which\x20the\x20SQL\x20query\x20should\x20be\x20performed.\n\n\x0f\n\x05\ + \x04\x06\x02\0\x04\x12\x06\xce\x02\x02\xcb\x02\x03\n\r\n\x05\x04\x06\x02\ + \0\x05\x12\x04\xce\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xce\ + \x02\t\x10\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xce\x02\x13\x14\n\xa7\x04\ + \n\x04\x04\x06\x02\x01\x12\x04\xdd\x02\x02&\x1a\x98\x04\x20The\x20transa\ + ction\x20to\x20use.\x20If\x20none\x20is\x20provided,\x20the\x20default\ + \x20is\x20a\n\x20temporary\x20read-only\x20transaction\x20with\x20strong\ + \x20concurrency.\n\n\x20The\x20transaction\x20to\x20use.\n\n\x20For\x20q\ + ueries,\x20if\x20none\x20is\x20provided,\x20the\x20default\x20is\x20a\ + \x20temporary\x20read-only\n\x20transaction\x20with\x20strong\x20concurr\ + ency.\n\n\x20Standard\x20DML\x20statements\x20require\x20a\x20ReadWrite\ + \x20transaction.\x20Single-use\n\x20transactions\x20are\x20not\x20suppor\ + ted\x20(to\x20avoid\x20replay).\x20\x20The\x20caller\x20must\n\x20either\ + \x20supply\x20an\x20existing\x20transaction\x20ID\x20or\x20begin\x20a\ + \x20new\x20transaction.\n\n\x20Partitioned\x20DML\x20requires\x20an\x20e\ + xisting\x20PartitionedDml\x20transaction\x20ID.\n\n\x0f\n\x05\x04\x06\ + \x02\x01\x04\x12\x06\xdd\x02\x02\xce\x02\x15\n\r\n\x05\x04\x06\x02\x01\ + \x06\x12\x04\xdd\x02\x02\x15\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xdd\ + \x02\x16!\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xdd\x02$%\n)\n\x04\x04\ + \x06\x02\x02\x12\x04\xe0\x02\x02\x11\x1a\x1b\x20Required.\x20The\x20SQL\ + \x20string.\n\n\x0f\n\x05\x04\x06\x02\x02\x04\x12\x06\xe0\x02\x02\xdd\ + \x02&\n\r\n\x05\x04\x06\x02\x02\x05\x12\x04\xe0\x02\x02\x08\n\r\n\x05\ + \x04\x06\x02\x02\x01\x12\x04\xe0\x02\t\x0c\n\r\n\x05\x04\x06\x02\x02\x03\ + \x12\x04\xe0\x02\x0f\x10\n\x81\x05\n\x04\x04\x06\x02\x03\x12\x04\xf0\x02\ + \x02$\x1a\xf2\x04\x20The\x20SQL\x20string\x20can\x20contain\x20parameter\ + \x20placeholders.\x20A\x20parameter\n\x20placeholder\x20consists\x20of\ + \x20`'@'`\x20followed\x20by\x20the\x20parameter\n\x20name.\x20Parameter\ + \x20names\x20consist\x20of\x20any\x20combination\x20of\x20letters,\n\x20\ + numbers,\x20and\x20underscores.\n\n\x20Parameters\x20can\x20appear\x20an\ + ywhere\x20that\x20a\x20literal\x20value\x20is\x20expected.\x20\x20The\ + \x20same\n\x20parameter\x20name\x20can\x20be\x20used\x20more\x20than\x20\ + once,\x20for\x20example:\n\x20\x20\x20`\"WHERE\x20id\x20>\x20@msg_id\x20\ + AND\x20id\x20<\x20@msg_id\x20+\x20100\"`\n\n\x20It\x20is\x20an\x20error\ + \x20to\x20execute\x20an\x20SQL\x20statement\x20with\x20unbound\x20parame\ + ters.\n\n\x20Parameter\x20values\x20are\x20specified\x20using\x20`params\ + `,\x20which\x20is\x20a\x20JSON\n\x20object\x20whose\x20keys\x20are\x20pa\ + rameter\x20names,\x20and\x20whose\x20values\x20are\x20the\n\x20correspon\ + ding\x20parameter\x20values.\n\n\x0f\n\x05\x04\x06\x02\x03\x04\x12\x06\ + \xf0\x02\x02\xe0\x02\x11\n\r\n\x05\x04\x06\x02\x03\x06\x12\x04\xf0\x02\ + \x02\x18\n\r\n\x05\x04\x06\x02\x03\x01\x12\x04\xf0\x02\x19\x1f\n\r\n\x05\ + \x04\x06\x02\x03\x03\x12\x04\xf0\x02\"#\n\xdc\x03\n\x04\x04\x06\x02\x04\ + \x12\x04\xfa\x02\x02$\x1a\xcd\x03\x20It\x20is\x20not\x20always\x20possib\ + le\x20for\x20Cloud\x20Spanner\x20to\x20infer\x20the\x20right\x20SQL\x20t\ + ype\n\x20from\x20a\x20JSON\x20value.\x20\x20For\x20example,\x20values\ + \x20of\x20type\x20`BYTES`\x20and\x20values\n\x20of\x20type\x20`STRING`\ + \x20both\x20appear\x20in\x20[params][google.spanner.v1.ExecuteSqlRequest\ + .params]\x20as\x20JSON\x20strings.\n\n\x20In\x20these\x20cases,\x20`para\ + m_types`\x20can\x20be\x20used\x20to\x20specify\x20the\x20exact\n\x20SQL\ + \x20type\x20for\x20some\x20or\x20all\x20of\x20the\x20SQL\x20statement\ + \x20parameters.\x20See\x20the\n\x20definition\x20of\x20[Type][google.spa\ + nner.v1.Type]\x20for\x20more\x20information\n\x20about\x20SQL\x20types.\ + \n\n\x0f\n\x05\x04\x06\x02\x04\x04\x12\x06\xfa\x02\x02\xf0\x02$\n\r\n\ + \x05\x04\x06\x02\x04\x06\x12\x04\xfa\x02\x02\x13\n\r\n\x05\x04\x06\x02\ + \x04\x01\x12\x04\xfa\x02\x14\x1f\n\r\n\x05\x04\x06\x02\x04\x03\x12\x04\ + \xfa\x02\"#\n\x9e\x03\n\x04\x04\x06\x02\x05\x12\x04\x82\x03\x02\x19\x1a\ + \x8f\x03\x20If\x20this\x20request\x20is\x20resuming\x20a\x20previously\ + \x20interrupted\x20SQL\x20statement\n\x20execution,\x20`resume_token`\ + \x20should\x20be\x20copied\x20from\x20the\x20last\n\x20[PartialResultSet\ + ][google.spanner.v1.PartialResultSet]\x20yielded\x20before\x20the\x20int\ + erruption.\x20Doing\x20this\n\x20enables\x20the\x20new\x20SQL\x20stateme\ + nt\x20execution\x20to\x20resume\x20where\x20the\x20last\x20one\x20left\n\ + \x20off.\x20The\x20rest\x20of\x20the\x20request\x20parameters\x20must\ + \x20exactly\x20match\x20the\n\x20request\x20that\x20yielded\x20this\x20t\ + oken.\n\n\x0f\n\x05\x04\x06\x02\x05\x04\x12\x06\x82\x03\x02\xfa\x02$\n\r\ + \n\x05\x04\x06\x02\x05\x05\x12\x04\x82\x03\x02\x07\n\r\n\x05\x04\x06\x02\ + \x05\x01\x12\x04\x82\x03\x08\x14\n\r\n\x05\x04\x06\x02\x05\x03\x12\x04\ + \x82\x03\x17\x18\n\xf2\x02\n\x04\x04\x06\x02\x06\x12\x04\x87\x03\x02\x1b\ + \x1a\xe3\x02\x20Used\x20to\x20control\x20the\x20amount\x20of\x20debuggin\ + g\x20information\x20returned\x20in\n\x20[ResultSetStats][google.spanner.\ + v1.ResultSetStats].\x20If\x20[partition_token][google.spanner.v1.Execute\ + SqlRequest.partition_token]\x20is\x20set,\x20[query_mode][google.spanner\ + .v1.ExecuteSqlRequest.query_mode]\x20can\x20only\n\x20be\x20set\x20to\ + \x20[QueryMode.NORMAL][google.spanner.v1.ExecuteSqlRequest.QueryMode.NOR\ + MAL].\n\n\x0f\n\x05\x04\x06\x02\x06\x04\x12\x06\x87\x03\x02\x82\x03\x19\ + \n\r\n\x05\x04\x06\x02\x06\x06\x12\x04\x87\x03\x02\x0b\n\r\n\x05\x04\x06\ + \x02\x06\x01\x12\x04\x87\x03\x0c\x16\n\r\n\x05\x04\x06\x02\x06\x03\x12\ + \x04\x87\x03\x19\x1a\n\x99\x02\n\x04\x04\x06\x02\x07\x12\x04\x8d\x03\x02\ + \x1c\x1a\x8a\x02\x20If\x20present,\x20results\x20will\x20be\x20restricte\ + d\x20to\x20the\x20specified\x20partition\n\x20previously\x20created\x20u\ + sing\x20PartitionQuery().\x20\x20There\x20must\x20be\x20an\x20exact\n\ + \x20match\x20for\x20the\x20values\x20of\x20fields\x20common\x20to\x20thi\ + s\x20message\x20and\x20the\n\x20PartitionQueryRequest\x20message\x20used\ + \x20to\x20create\x20this\x20partition_token.\n\n\x0f\n\x05\x04\x06\x02\ + \x07\x04\x12\x06\x8d\x03\x02\x87\x03\x1b\n\r\n\x05\x04\x06\x02\x07\x05\ + \x12\x04\x8d\x03\x02\x07\n\r\n\x05\x04\x06\x02\x07\x01\x12\x04\x8d\x03\ + \x08\x17\n\r\n\x05\x04\x06\x02\x07\x03\x12\x04\x8d\x03\x1a\x1b\n\x95\x04\ + \n\x04\x04\x06\x02\x08\x12\x04\x99\x03\x02\x12\x1a\x86\x04\x20A\x20per-t\ + ransaction\x20sequence\x20number\x20used\x20to\x20identify\x20this\x20re\ + quest.\x20This\n\x20makes\x20each\x20request\x20idempotent\x20such\x20th\ + at\x20if\x20the\x20request\x20is\x20received\x20multiple\n\x20times,\x20\ + at\x20most\x20one\x20will\x20succeed.\n\n\x20The\x20sequence\x20number\ + \x20must\x20be\x20monotonically\x20increasing\x20within\x20the\n\x20tran\ + saction.\x20If\x20a\x20request\x20arrives\x20for\x20the\x20first\x20time\ + \x20with\x20an\x20out-of-order\n\x20sequence\x20number,\x20the\x20transa\ + ction\x20may\x20be\x20aborted.\x20Replays\x20of\x20previously\n\x20handl\ + ed\x20requests\x20will\x20yield\x20the\x20same\x20response\x20as\x20the\ + \x20first\x20execution.\n\n\x20Required\x20for\x20DML\x20statements.\x20\ + Ignored\x20for\x20queries.\n\n\x0f\n\x05\x04\x06\x02\x08\x04\x12\x06\x99\ + \x03\x02\x8d\x03\x1c\n\r\n\x05\x04\x06\x02\x08\x05\x12\x04\x99\x03\x02\ + \x07\n\r\n\x05\x04\x06\x02\x08\x01\x12\x04\x99\x03\x08\r\n\r\n\x05\x04\ + \x06\x02\x08\x03\x12\x04\x99\x03\x10\x11\nN\n\x02\x04\x07\x12\x06\x9e\ + \x03\0\xb0\x03\x01\x1a@\x20Options\x20for\x20a\x20PartitionQueryRequest\ + \x20and\n\x20PartitionReadRequest.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\x9e\ + \x03\x08\x18\n\xba\x02\n\x04\x04\x07\x02\0\x12\x04\xa5\x03\x02!\x1a\xab\ + \x02\x20**Note:**\x20This\x20hint\x20is\x20currently\x20ignored\x20by\ + \x20PartitionQuery\x20and\n\x20PartitionRead\x20requests.\n\n\x20The\x20\ + desired\x20data\x20size\x20for\x20each\x20partition\x20generated.\x20\ + \x20The\x20default\x20for\x20this\n\x20option\x20is\x20currently\x201\ + \x20GiB.\x20\x20This\x20is\x20only\x20a\x20hint.\x20The\x20actual\x20siz\ + e\x20of\x20each\n\x20partition\x20may\x20be\x20smaller\x20or\x20larger\ + \x20than\x20this\x20size\x20request.\n\n\x0f\n\x05\x04\x07\x02\0\x04\x12\ + \x06\xa5\x03\x02\x9e\x03\x1a\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xa5\x03\ + \x02\x07\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xa5\x03\x08\x1c\n\r\n\x05\ + \x04\x07\x02\0\x03\x12\x04\xa5\x03\x1f\x20\n\xb8\x03\n\x04\x04\x07\x02\ + \x01\x12\x04\xaf\x03\x02\x1b\x1a\xa9\x03\x20**Note:**\x20This\x20hint\ + \x20is\x20currently\x20ignored\x20by\x20PartitionQuery\x20and\n\x20Parti\ + tionRead\x20requests.\n\n\x20The\x20desired\x20maximum\x20number\x20of\ + \x20partitions\x20to\x20return.\x20\x20For\x20example,\x20this\x20may\n\ + \x20be\x20set\x20to\x20the\x20number\x20of\x20workers\x20available.\x20\ + \x20The\x20default\x20for\x20this\x20option\n\x20is\x20currently\x2010,0\ + 00.\x20The\x20maximum\x20value\x20is\x20currently\x20200,000.\x20\x20Thi\ + s\x20is\x20only\n\x20a\x20hint.\x20\x20The\x20actual\x20number\x20of\x20\ + partitions\x20returned\x20may\x20be\x20smaller\x20or\x20larger\n\x20than\ + \x20this\x20maximum\x20count\x20request.\n\n\x0f\n\x05\x04\x07\x02\x01\ + \x04\x12\x06\xaf\x03\x02\xa5\x03!\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\ + \xaf\x03\x02\x07\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\xaf\x03\x08\x16\n\ + \r\n\x05\x04\x07\x02\x01\x03\x12\x04\xaf\x03\x19\x1a\nZ\n\x02\x04\x08\ + \x12\x06\xb3\x03\0\xe3\x03\x01\x1aL\x20The\x20request\x20for\x20[Partiti\ + onQuery][google.spanner.v1.Spanner.PartitionQuery]\n\n\x0b\n\x03\x04\x08\ + \x01\x12\x04\xb3\x03\x08\x1d\nD\n\x04\x04\x08\x02\0\x12\x04\xb5\x03\x02\ + \x15\x1a6\x20Required.\x20The\x20session\x20used\x20to\x20create\x20the\ + \x20partitions.\n\n\x0f\n\x05\x04\x08\x02\0\x04\x12\x06\xb5\x03\x02\xb3\ + \x03\x1f\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\xb5\x03\x02\x08\n\r\n\x05\ + \x04\x08\x02\0\x01\x12\x04\xb5\x03\t\x10\n\r\n\x05\x04\x08\x02\0\x03\x12\ + \x04\xb5\x03\x13\x14\no\n\x04\x04\x08\x02\x01\x12\x04\xb9\x03\x02&\x1aa\ + \x20Read\x20only\x20snapshot\x20transactions\x20are\x20supported,\x20rea\ + d/write\x20and\x20single\x20use\n\x20transactions\x20are\x20not.\n\n\x0f\ + \n\x05\x04\x08\x02\x01\x04\x12\x06\xb9\x03\x02\xb5\x03\x15\n\r\n\x05\x04\ + \x08\x02\x01\x06\x12\x04\xb9\x03\x02\x15\n\r\n\x05\x04\x08\x02\x01\x01\ + \x12\x04\xb9\x03\x16!\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xb9\x03$%\n\ + \xee\x04\n\x04\x04\x08\x02\x02\x12\x04\xc5\x03\x02\x11\x1a\xdf\x04\x20Th\ + e\x20query\x20request\x20to\x20generate\x20partitions\x20for.\x20The\x20\ + request\x20will\x20fail\x20if\n\x20the\x20query\x20is\x20not\x20root\x20\ + partitionable.\x20The\x20query\x20plan\x20of\x20a\x20root\n\x20partition\ + able\x20query\x20has\x20a\x20single\x20distributed\x20union\x20operator.\ + \x20A\x20distributed\n\x20union\x20operator\x20conceptually\x20divides\ + \x20one\x20or\x20more\x20tables\x20into\x20multiple\n\x20splits,\x20remo\ + tely\x20evaluates\x20a\x20subquery\x20independently\x20on\x20each\x20spl\ + it,\x20and\n\x20then\x20unions\x20all\x20results.\n\n\x20This\x20must\ + \x20not\x20contain\x20DML\x20commands,\x20such\x20as\x20INSERT,\x20UPDAT\ + E,\x20or\n\x20DELETE.\x20Use\x20[ExecuteStreamingSql][google.spanner.v1.\ + Spanner.ExecuteStreamingSql]\x20with\x20a\n\x20PartitionedDml\x20transac\ + tion\x20for\x20large,\x20partition-friendly\x20DML\x20operations.\n\n\ + \x0f\n\x05\x04\x08\x02\x02\x04\x12\x06\xc5\x03\x02\xb9\x03&\n\r\n\x05\ + \x04\x08\x02\x02\x05\x12\x04\xc5\x03\x02\x08\n\r\n\x05\x04\x08\x02\x02\ + \x01\x12\x04\xc5\x03\t\x0c\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xc5\x03\ + \x0f\x10\n\x83\x05\n\x04\x04\x08\x02\x03\x12\x04\xd5\x03\x02$\x1a\xf4\ + \x04\x20The\x20SQL\x20query\x20string\x20can\x20contain\x20parameter\x20\ + placeholders.\x20A\x20parameter\n\x20placeholder\x20consists\x20of\x20`'\ + @'`\x20followed\x20by\x20the\x20parameter\n\x20name.\x20Parameter\x20nam\ + es\x20consist\x20of\x20any\x20combination\x20of\x20letters,\n\x20numbers\ + ,\x20and\x20underscores.\n\n\x20Parameters\x20can\x20appear\x20anywhere\ + \x20that\x20a\x20literal\x20value\x20is\x20expected.\x20\x20The\x20same\ + \n\x20parameter\x20name\x20can\x20be\x20used\x20more\x20than\x20once,\ + \x20for\x20example:\n\x20\x20\x20`\"WHERE\x20id\x20>\x20@msg_id\x20AND\ + \x20id\x20<\x20@msg_id\x20+\x20100\"`\n\n\x20It\x20is\x20an\x20error\x20\ + to\x20execute\x20an\x20SQL\x20query\x20with\x20unbound\x20parameters.\n\ + \n\x20Parameter\x20values\x20are\x20specified\x20using\x20`params`,\x20w\ + hich\x20is\x20a\x20JSON\n\x20object\x20whose\x20keys\x20are\x20parameter\ + \x20names,\x20and\x20whose\x20values\x20are\x20the\n\x20corresponding\ + \x20parameter\x20values.\n\n\x0f\n\x05\x04\x08\x02\x03\x04\x12\x06\xd5\ + \x03\x02\xc5\x03\x11\n\r\n\x05\x04\x08\x02\x03\x06\x12\x04\xd5\x03\x02\ + \x18\n\r\n\x05\x04\x08\x02\x03\x01\x12\x04\xd5\x03\x19\x1f\n\r\n\x05\x04\ + \x08\x02\x03\x03\x12\x04\xd5\x03\"#\n\xdc\x03\n\x04\x04\x08\x02\x04\x12\ + \x04\xdf\x03\x02$\x1a\xcd\x03\x20It\x20is\x20not\x20always\x20possible\ + \x20for\x20Cloud\x20Spanner\x20to\x20infer\x20the\x20right\x20SQL\x20typ\ + e\n\x20from\x20a\x20JSON\x20value.\x20\x20For\x20example,\x20values\x20o\ + f\x20type\x20`BYTES`\x20and\x20values\n\x20of\x20type\x20`STRING`\x20bot\ + h\x20appear\x20in\x20[params][google.spanner.v1.PartitionQueryRequest.pa\ + rams]\x20as\x20JSON\x20strings.\n\n\x20In\x20these\x20cases,\x20`param_t\ + ypes`\x20can\x20be\x20used\x20to\x20specify\x20the\x20exact\n\x20SQL\x20\ + type\x20for\x20some\x20or\x20all\x20of\x20the\x20SQL\x20query\x20paramet\ + ers.\x20See\x20the\n\x20definition\x20of\x20[Type][google.spanner.v1.Typ\ + e]\x20for\x20more\x20information\n\x20about\x20SQL\x20types.\n\n\x0f\n\ + \x05\x04\x08\x02\x04\x04\x12\x06\xdf\x03\x02\xd5\x03$\n\r\n\x05\x04\x08\ + \x02\x04\x06\x12\x04\xdf\x03\x02\x13\n\r\n\x05\x04\x08\x02\x04\x01\x12\ + \x04\xdf\x03\x14\x1f\n\r\n\x05\x04\x08\x02\x04\x03\x12\x04\xdf\x03\"#\nO\ + \n\x04\x04\x08\x02\x05\x12\x04\xe2\x03\x02)\x1aA\x20Additional\x20option\ + s\x20that\x20affect\x20how\x20many\x20partitions\x20are\x20created.\n\n\ + \x0f\n\x05\x04\x08\x02\x05\x04\x12\x06\xe2\x03\x02\xdf\x03$\n\r\n\x05\ + \x04\x08\x02\x05\x06\x12\x04\xe2\x03\x02\x12\n\r\n\x05\x04\x08\x02\x05\ + \x01\x12\x04\xe2\x03\x13$\n\r\n\x05\x04\x08\x02\x05\x03\x12\x04\xe2\x03'\ + (\nX\n\x02\x04\t\x12\x06\xe6\x03\0\x85\x04\x01\x1aJ\x20The\x20request\ + \x20for\x20[PartitionRead][google.spanner.v1.Spanner.PartitionRead]\n\n\ + \x0b\n\x03\x04\t\x01\x12\x04\xe6\x03\x08\x1c\nD\n\x04\x04\t\x02\0\x12\ + \x04\xe8\x03\x02\x15\x1a6\x20Required.\x20The\x20session\x20used\x20to\ + \x20create\x20the\x20partitions.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\x06\ + \xe8\x03\x02\xe6\x03\x1e\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xe8\x03\x02\ + \x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xe8\x03\t\x10\n\r\n\x05\x04\t\x02\ + \0\x03\x12\x04\xe8\x03\x13\x14\no\n\x04\x04\t\x02\x01\x12\x04\xec\x03\ + \x02&\x1aa\x20Read\x20only\x20snapshot\x20transactions\x20are\x20support\ + ed,\x20read/write\x20and\x20single\x20use\n\x20transactions\x20are\x20no\ + t.\n\n\x0f\n\x05\x04\t\x02\x01\x04\x12\x06\xec\x03\x02\xe8\x03\x15\n\r\n\ + \x05\x04\t\x02\x01\x06\x12\x04\xec\x03\x02\x15\n\r\n\x05\x04\t\x02\x01\ + \x01\x12\x04\xec\x03\x16!\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xec\x03$%\ + \nK\n\x04\x04\t\x02\x02\x12\x04\xef\x03\x02\x13\x1a=\x20Required.\x20The\ + \x20name\x20of\x20the\x20table\x20in\x20the\x20database\x20to\x20be\x20r\ + ead.\n\n\x0f\n\x05\x04\t\x02\x02\x04\x12\x06\xef\x03\x02\xec\x03&\n\r\n\ + \x05\x04\t\x02\x02\x05\x12\x04\xef\x03\x02\x08\n\r\n\x05\x04\t\x02\x02\ + \x01\x12\x04\xef\x03\t\x0e\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xef\x03\ + \x11\x12\n\xdf\x02\n\x04\x04\t\x02\x03\x12\x04\xf4\x03\x02\x13\x1a\xd0\ + \x02\x20If\x20non-empty,\x20the\x20name\x20of\x20an\x20index\x20on\x20[t\ + able][google.spanner.v1.PartitionReadRequest.table].\x20This\x20index\ + \x20is\n\x20used\x20instead\x20of\x20the\x20table\x20primary\x20key\x20w\ + hen\x20interpreting\x20[key_set][google.spanner.v1.PartitionReadRequest.\ + key_set]\n\x20and\x20sorting\x20result\x20rows.\x20See\x20[key_set][goog\ + le.spanner.v1.PartitionReadRequest.key_set]\x20for\x20further\x20informa\ + tion.\n\n\x0f\n\x05\x04\t\x02\x03\x04\x12\x06\xf4\x03\x02\xef\x03\x13\n\ + \r\n\x05\x04\t\x02\x03\x05\x12\x04\xf4\x03\x02\x08\n\r\n\x05\x04\t\x02\ + \x03\x01\x12\x04\xf4\x03\t\x0e\n\r\n\x05\x04\t\x02\x03\x03\x12\x04\xf4\ + \x03\x11\x12\n\x88\x01\n\x04\x04\t\x02\x04\x12\x04\xf8\x03\x02\x1e\x1az\ + \x20The\x20columns\x20of\x20[table][google.spanner.v1.PartitionReadReque\ + st.table]\x20to\x20be\x20returned\x20for\x20each\x20row\x20matching\n\ + \x20this\x20request.\n\n\r\n\x05\x04\t\x02\x04\x04\x12\x04\xf8\x03\x02\n\ + \n\r\n\x05\x04\t\x02\x04\x05\x12\x04\xf8\x03\x0b\x11\n\r\n\x05\x04\t\x02\ + \x04\x01\x12\x04\xf8\x03\x12\x19\n\r\n\x05\x04\t\x02\x04\x03\x12\x04\xf8\ + \x03\x1c\x1d\n\xe1\x04\n\x04\x04\t\x02\x05\x12\x04\x81\x04\x02\x15\x1a\ + \xd2\x04\x20Required.\x20`key_set`\x20identifies\x20the\x20rows\x20to\ + \x20be\x20yielded.\x20`key_set`\x20names\x20the\n\x20primary\x20keys\x20\ + of\x20the\x20rows\x20in\x20[table][google.spanner.v1.PartitionReadReques\ + t.table]\x20to\x20be\x20yielded,\x20unless\x20[index][google.spanner.v1.\ + PartitionReadRequest.index]\n\x20is\x20present.\x20If\x20[index][google.\ + spanner.v1.PartitionReadRequest.index]\x20is\x20present,\x20then\x20[key\ + _set][google.spanner.v1.PartitionReadRequest.key_set]\x20instead\x20name\ + s\n\x20index\x20keys\x20in\x20[index][google.spanner.v1.PartitionReadReq\ + uest.index].\n\n\x20It\x20is\x20not\x20an\x20error\x20for\x20the\x20`key\ + _set`\x20to\x20name\x20rows\x20that\x20do\x20not\n\x20exist\x20in\x20the\ + \x20database.\x20Read\x20yields\x20nothing\x20for\x20nonexistent\x20rows\ + .\n\n\x0f\n\x05\x04\t\x02\x05\x04\x12\x06\x81\x04\x02\xf8\x03\x1e\n\r\n\ + \x05\x04\t\x02\x05\x06\x12\x04\x81\x04\x02\x08\n\r\n\x05\x04\t\x02\x05\ + \x01\x12\x04\x81\x04\t\x10\n\r\n\x05\x04\t\x02\x05\x03\x12\x04\x81\x04\ + \x13\x14\nO\n\x04\x04\t\x02\x06\x12\x04\x84\x04\x02)\x1aA\x20Additional\ + \x20options\x20that\x20affect\x20how\x20many\x20partitions\x20are\x20cre\ + ated.\n\n\x0f\n\x05\x04\t\x02\x06\x04\x12\x06\x84\x04\x02\x81\x04\x15\n\ + \r\n\x05\x04\t\x02\x06\x06\x12\x04\x84\x04\x02\x12\n\r\n\x05\x04\t\x02\ + \x06\x01\x12\x04\x84\x04\x13$\n\r\n\x05\x04\t\x02\x06\x03\x12\x04\x84\ + \x04'(\nY\n\x02\x04\n\x12\x06\x89\x04\0\x8e\x04\x01\x1aK\x20Information\ + \x20returned\x20for\x20each\x20partition\x20returned\x20in\x20a\n\x20Par\ + titionResponse.\n\n\x0b\n\x03\x04\n\x01\x12\x04\x89\x04\x08\x11\n\xb4\ + \x01\n\x04\x04\n\x02\0\x12\x04\x8d\x04\x02\x1c\x1a\xa5\x01\x20This\x20to\ + ken\x20can\x20be\x20passed\x20to\x20Read,\x20StreamingRead,\x20ExecuteSq\ + l,\x20or\n\x20ExecuteStreamingSql\x20requests\x20to\x20restrict\x20the\ + \x20results\x20to\x20those\x20identified\x20by\n\x20this\x20partition\ + \x20token.\n\n\x0f\n\x05\x04\n\x02\0\x04\x12\x06\x8d\x04\x02\x89\x04\x13\ + \n\r\n\x05\x04\n\x02\0\x05\x12\x04\x8d\x04\x02\x07\n\r\n\x05\x04\n\x02\0\ + \x01\x12\x04\x8d\x04\x08\x17\n\r\n\x05\x04\n\x02\0\x03\x12\x04\x8d\x04\ + \x1a\x1b\n\x99\x01\n\x02\x04\x0b\x12\x06\x92\x04\0\x98\x04\x01\x1a\x8a\ + \x01\x20The\x20response\x20for\x20[PartitionQuery][google.spanner.v1.Spa\ + nner.PartitionQuery]\n\x20or\x20[PartitionRead][google.spanner.v1.Spanne\ + r.PartitionRead]\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\x92\x04\x08\x19\n3\n\ + \x04\x04\x0b\x02\0\x12\x04\x94\x04\x02$\x1a%\x20Partitions\x20created\ + \x20by\x20this\x20request.\n\n\r\n\x05\x04\x0b\x02\0\x04\x12\x04\x94\x04\ + \x02\n\n\r\n\x05\x04\x0b\x02\0\x06\x12\x04\x94\x04\x0b\x14\n\r\n\x05\x04\ + \x0b\x02\0\x01\x12\x04\x94\x04\x15\x1f\n\r\n\x05\x04\x0b\x02\0\x03\x12\ + \x04\x94\x04\"#\n4\n\x04\x04\x0b\x02\x01\x12\x04\x97\x04\x02\x1e\x1a&\ + \x20Transaction\x20created\x20by\x20this\x20request.\n\n\x0f\n\x05\x04\ + \x0b\x02\x01\x04\x12\x06\x97\x04\x02\x94\x04$\n\r\n\x05\x04\x0b\x02\x01\ + \x06\x12\x04\x97\x04\x02\r\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\x97\x04\ + \x0e\x19\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\x97\x04\x1c\x1d\n\x85\x01\ + \n\x02\x04\x0c\x12\x06\x9c\x04\0\xd0\x04\x01\x1aw\x20The\x20request\x20f\ + or\x20[Read][google.spanner.v1.Spanner.Read]\x20and\n\x20[StreamingRead]\ + [google.spanner.v1.Spanner.StreamingRead].\n\n\x0b\n\x03\x04\x0c\x01\x12\ + \x04\x9c\x04\x08\x13\nL\n\x04\x04\x0c\x02\0\x12\x04\x9e\x04\x02\x15\x1a>\ + \x20Required.\x20The\x20session\x20in\x20which\x20the\x20read\x20should\ + \x20be\x20performed.\n\n\x0f\n\x05\x04\x0c\x02\0\x04\x12\x06\x9e\x04\x02\ + \x9c\x04\x15\n\r\n\x05\x04\x0c\x02\0\x05\x12\x04\x9e\x04\x02\x08\n\r\n\ + \x05\x04\x0c\x02\0\x01\x12\x04\x9e\x04\t\x10\n\r\n\x05\x04\x0c\x02\0\x03\ + \x12\x04\x9e\x04\x13\x14\n\x87\x01\n\x04\x04\x0c\x02\x01\x12\x04\xa2\x04\ + \x02&\x1ay\x20The\x20transaction\x20to\x20use.\x20If\x20none\x20is\x20pr\ + ovided,\x20the\x20default\x20is\x20a\n\x20temporary\x20read-only\x20tran\ + saction\x20with\x20strong\x20concurrency.\n\n\x0f\n\x05\x04\x0c\x02\x01\ + \x04\x12\x06\xa2\x04\x02\x9e\x04\x15\n\r\n\x05\x04\x0c\x02\x01\x06\x12\ + \x04\xa2\x04\x02\x15\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\xa2\x04\x16!\ + \n\r\n\x05\x04\x0c\x02\x01\x03\x12\x04\xa2\x04$%\nK\n\x04\x04\x0c\x02\ + \x02\x12\x04\xa5\x04\x02\x13\x1a=\x20Required.\x20The\x20name\x20of\x20t\ + he\x20table\x20in\x20the\x20database\x20to\x20be\x20read.\n\n\x0f\n\x05\ + \x04\x0c\x02\x02\x04\x12\x06\xa5\x04\x02\xa2\x04&\n\r\n\x05\x04\x0c\x02\ + \x02\x05\x12\x04\xa5\x04\x02\x08\n\r\n\x05\x04\x0c\x02\x02\x01\x12\x04\ + \xa5\x04\t\x0e\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xa5\x04\x11\x12\n\ + \xc4\x02\n\x04\x04\x0c\x02\x03\x12\x04\xaa\x04\x02\x13\x1a\xb5\x02\x20If\ + \x20non-empty,\x20the\x20name\x20of\x20an\x20index\x20on\x20[table][goog\ + le.spanner.v1.ReadRequest.table].\x20This\x20index\x20is\n\x20used\x20in\ + stead\x20of\x20the\x20table\x20primary\x20key\x20when\x20interpreting\ + \x20[key_set][google.spanner.v1.ReadRequest.key_set]\n\x20and\x20sorting\ + \x20result\x20rows.\x20See\x20[key_set][google.spanner.v1.ReadRequest.ke\ + y_set]\x20for\x20further\x20information.\n\n\x0f\n\x05\x04\x0c\x02\x03\ + \x04\x12\x06\xaa\x04\x02\xa5\x04\x13\n\r\n\x05\x04\x0c\x02\x03\x05\x12\ + \x04\xaa\x04\x02\x08\n\r\n\x05\x04\x0c\x02\x03\x01\x12\x04\xaa\x04\t\x0e\ + \n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\xaa\x04\x11\x12\n\x7f\n\x04\x04\ + \x0c\x02\x04\x12\x04\xae\x04\x02\x1e\x1aq\x20The\x20columns\x20of\x20[ta\ + ble][google.spanner.v1.ReadRequest.table]\x20to\x20be\x20returned\x20for\ + \x20each\x20row\x20matching\n\x20this\x20request.\n\n\r\n\x05\x04\x0c\ + \x02\x04\x04\x12\x04\xae\x04\x02\n\n\r\n\x05\x04\x0c\x02\x04\x05\x12\x04\ + \xae\x04\x0b\x11\n\r\n\x05\x04\x0c\x02\x04\x01\x12\x04\xae\x04\x12\x19\n\ + \r\n\x05\x04\x0c\x02\x04\x03\x12\x04\xae\x04\x1c\x1d\n\xd6\x07\n\x04\x04\ + \x0c\x02\x05\x12\x04\xbc\x04\x02\x15\x1a\xc7\x07\x20Required.\x20`key_se\ + t`\x20identifies\x20the\x20rows\x20to\x20be\x20yielded.\x20`key_set`\x20\ + names\x20the\n\x20primary\x20keys\x20of\x20the\x20rows\x20in\x20[table][\ + google.spanner.v1.ReadRequest.table]\x20to\x20be\x20yielded,\x20unless\ + \x20[index][google.spanner.v1.ReadRequest.index]\n\x20is\x20present.\x20\ + If\x20[index][google.spanner.v1.ReadRequest.index]\x20is\x20present,\x20\ + then\x20[key_set][google.spanner.v1.ReadRequest.key_set]\x20instead\x20n\ + ames\n\x20index\x20keys\x20in\x20[index][google.spanner.v1.ReadRequest.i\ + ndex].\n\n\x20If\x20the\x20[partition_token][google.spanner.v1.ReadReque\ + st.partition_token]\x20field\x20is\x20empty,\x20rows\x20are\x20yielded\n\ + \x20in\x20table\x20primary\x20key\x20order\x20(if\x20[index][google.span\ + ner.v1.ReadRequest.index]\x20is\x20empty)\x20or\x20index\x20key\x20order\ + \n\x20(if\x20[index][google.spanner.v1.ReadRequest.index]\x20is\x20non-e\ + mpty).\x20\x20If\x20the\x20[partition_token][google.spanner.v1.ReadReque\ + st.partition_token]\x20field\x20is\x20not\n\x20empty,\x20rows\x20will\ + \x20be\x20yielded\x20in\x20an\x20unspecified\x20order.\n\n\x20It\x20is\ + \x20not\x20an\x20error\x20for\x20the\x20`key_set`\x20to\x20name\x20rows\ + \x20that\x20do\x20not\n\x20exist\x20in\x20the\x20database.\x20Read\x20yi\ + elds\x20nothing\x20for\x20nonexistent\x20rows.\n\n\x0f\n\x05\x04\x0c\x02\ + \x05\x04\x12\x06\xbc\x04\x02\xae\x04\x1e\n\r\n\x05\x04\x0c\x02\x05\x06\ + \x12\x04\xbc\x04\x02\x08\n\r\n\x05\x04\x0c\x02\x05\x01\x12\x04\xbc\x04\t\ + \x10\n\r\n\x05\x04\x0c\x02\x05\x03\x12\x04\xbc\x04\x13\x14\n\xb7\x01\n\ + \x04\x04\x0c\x02\x06\x12\x04\xc1\x04\x02\x12\x1a\xa8\x01\x20If\x20greate\ + r\x20than\x20zero,\x20only\x20the\x20first\x20`limit`\x20rows\x20are\x20\ + yielded.\x20If\x20`limit`\n\x20is\x20zero,\x20the\x20default\x20is\x20no\ + \x20limit.\x20A\x20limit\x20cannot\x20be\x20specified\x20if\n\x20`partit\ + ion_token`\x20is\x20set.\n\n\x0f\n\x05\x04\x0c\x02\x06\x04\x12\x06\xc1\ + \x04\x02\xbc\x04\x15\n\r\n\x05\x04\x0c\x02\x06\x05\x12\x04\xc1\x04\x02\ + \x07\n\r\n\x05\x04\x0c\x02\x06\x01\x12\x04\xc1\x04\x08\r\n\r\n\x05\x04\ + \x0c\x02\x06\x03\x12\x04\xc1\x04\x10\x11\n\xf9\x02\n\x04\x04\x0c\x02\x07\ + \x12\x04\xc9\x04\x02\x19\x1a\xea\x02\x20If\x20this\x20request\x20is\x20r\ + esuming\x20a\x20previously\x20interrupted\x20read,\n\x20`resume_token`\ + \x20should\x20be\x20copied\x20from\x20the\x20last\n\x20[PartialResultSet\ + ][google.spanner.v1.PartialResultSet]\x20yielded\x20before\x20the\x20int\ + erruption.\x20Doing\x20this\n\x20enables\x20the\x20new\x20read\x20to\x20\ + resume\x20where\x20the\x20last\x20read\x20left\x20off.\x20The\n\x20rest\ + \x20of\x20the\x20request\x20parameters\x20must\x20exactly\x20match\x20th\ + e\x20request\n\x20that\x20yielded\x20this\x20token.\n\n\x0f\n\x05\x04\ + \x0c\x02\x07\x04\x12\x06\xc9\x04\x02\xc1\x04\x12\n\r\n\x05\x04\x0c\x02\ + \x07\x05\x12\x04\xc9\x04\x02\x07\n\r\n\x05\x04\x0c\x02\x07\x01\x12\x04\ + \xc9\x04\x08\x14\n\r\n\x05\x04\x0c\x02\x07\x03\x12\x04\xc9\x04\x17\x18\n\ + \x99\x02\n\x04\x04\x0c\x02\x08\x12\x04\xcf\x04\x02\x1d\x1a\x8a\x02\x20If\ + \x20present,\x20results\x20will\x20be\x20restricted\x20to\x20the\x20spec\ + ified\x20partition\n\x20previously\x20created\x20using\x20PartitionRead(\ + ).\x20\x20\x20\x20There\x20must\x20be\x20an\x20exact\n\x20match\x20for\ + \x20the\x20values\x20of\x20fields\x20common\x20to\x20this\x20message\x20\ + and\x20the\n\x20PartitionReadRequest\x20message\x20used\x20to\x20create\ + \x20this\x20partition_token.\n\n\x0f\n\x05\x04\x0c\x02\x08\x04\x12\x06\ + \xcf\x04\x02\xc9\x04\x19\n\r\n\x05\x04\x0c\x02\x08\x05\x12\x04\xcf\x04\ + \x02\x07\n\r\n\x05\x04\x0c\x02\x08\x01\x12\x04\xcf\x04\x08\x17\n\r\n\x05\ + \x04\x0c\x02\x08\x03\x12\x04\xcf\x04\x1a\x1c\n_\n\x02\x04\r\x12\x06\xd3\ + \x04\0\xd9\x04\x01\x1aQ\x20The\x20request\x20for\x20[BeginTransaction][g\ + oogle.spanner.v1.Spanner.BeginTransaction].\n\n\x0b\n\x03\x04\r\x01\x12\ + \x04\xd3\x04\x08\x1f\nD\n\x04\x04\r\x02\0\x12\x04\xd5\x04\x02\x15\x1a6\ + \x20Required.\x20The\x20session\x20in\x20which\x20the\x20transaction\x20\ + runs.\n\n\x0f\n\x05\x04\r\x02\0\x04\x12\x06\xd5\x04\x02\xd3\x04!\n\r\n\ + \x05\x04\r\x02\0\x05\x12\x04\xd5\x04\x02\x08\n\r\n\x05\x04\r\x02\0\x01\ + \x12\x04\xd5\x04\t\x10\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xd5\x04\x13\x14\ + \n:\n\x04\x04\r\x02\x01\x12\x04\xd8\x04\x02!\x1a,\x20Required.\x20Option\ + s\x20for\x20the\x20new\x20transaction.\n\n\x0f\n\x05\x04\r\x02\x01\x04\ + \x12\x06\xd8\x04\x02\xd5\x04\x15\n\r\n\x05\x04\r\x02\x01\x06\x12\x04\xd8\ + \x04\x02\x14\n\r\n\x05\x04\r\x02\x01\x01\x12\x04\xd8\x04\x15\x1c\n\r\n\ + \x05\x04\r\x02\x01\x03\x12\x04\xd8\x04\x1f\x20\nK\n\x02\x04\x0e\x12\x06\ + \xdc\x04\0\xf5\x04\x01\x1a=\x20The\x20request\x20for\x20[Commit][google.\ + spanner.v1.Spanner.Commit].\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\xdc\x04\ + \x08\x15\nZ\n\x04\x04\x0e\x02\0\x12\x04\xde\x04\x02\x15\x1aL\x20Required\ + .\x20The\x20session\x20in\x20which\x20the\x20transaction\x20to\x20be\x20\ + committed\x20is\x20running.\n\n\x0f\n\x05\x04\x0e\x02\0\x04\x12\x06\xde\ + \x04\x02\xdc\x04\x17\n\r\n\x05\x04\x0e\x02\0\x05\x12\x04\xde\x04\x02\x08\ + \n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xde\x04\t\x10\n\r\n\x05\x04\x0e\x02\ + \0\x03\x12\x04\xde\x04\x13\x14\n?\n\x04\x04\x0e\x08\0\x12\x06\xe1\x04\ + \x02\xef\x04\x03\x1a/\x20Required.\x20The\x20transaction\x20in\x20which\ + \x20to\x20commit.\n\n\r\n\x05\x04\x0e\x08\0\x01\x12\x04\xe1\x04\x08\x13\ + \n8\n\x04\x04\x0e\x02\x01\x12\x04\xe3\x04\x04\x1d\x1a*\x20Commit\x20a\ + \x20previously-started\x20transaction.\n\n\r\n\x05\x04\x0e\x02\x01\x05\ + \x12\x04\xe3\x04\x04\t\n\r\n\x05\x04\x0e\x02\x01\x01\x12\x04\xe3\x04\n\ + \x18\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\xe3\x04\x1b\x1c\n\xa4\x04\n\ + \x04\x04\x0e\x02\x02\x12\x04\xee\x04\x042\x1a\x95\x04\x20Execute\x20muta\ + tions\x20in\x20a\x20temporary\x20transaction.\x20Note\x20that\x20unlike\ + \n\x20commit\x20of\x20a\x20previously-started\x20transaction,\x20commit\ + \x20with\x20a\n\x20temporary\x20transaction\x20is\x20non-idempotent.\x20\ + That\x20is,\x20if\x20the\n\x20`CommitRequest`\x20is\x20sent\x20to\x20Clo\ + ud\x20Spanner\x20more\x20than\x20once\x20(for\n\x20instance,\x20due\x20t\ + o\x20retries\x20in\x20the\x20application,\x20or\x20in\x20the\n\x20transp\ + ort\x20library),\x20it\x20is\x20possible\x20that\x20the\x20mutations\x20\ + are\n\x20executed\x20more\x20than\x20once.\x20If\x20this\x20is\x20undesi\ + rable,\x20use\n\x20[BeginTransaction][google.spanner.v1.Spanner.BeginTra\ + nsaction]\x20and\n\x20[Commit][google.spanner.v1.Spanner.Commit]\x20inst\ + ead.\n\n\r\n\x05\x04\x0e\x02\x02\x06\x12\x04\xee\x04\x04\x16\n\r\n\x05\ + \x04\x0e\x02\x02\x01\x12\x04\xee\x04\x17-\n\r\n\x05\x04\x0e\x02\x02\x03\ + \x12\x04\xee\x0401\n\x9b\x01\n\x04\x04\x0e\x02\x03\x12\x04\xf4\x04\x02\"\ + \x1a\x8c\x01\x20The\x20mutations\x20to\x20be\x20executed\x20when\x20this\ + \x20transaction\x20commits.\x20All\n\x20mutations\x20are\x20applied\x20a\ + tomically,\x20in\x20the\x20order\x20they\x20appear\x20in\n\x20this\x20li\ + st.\n\n\r\n\x05\x04\x0e\x02\x03\x04\x12\x04\xf4\x04\x02\n\n\r\n\x05\x04\ + \x0e\x02\x03\x06\x12\x04\xf4\x04\x0b\x13\n\r\n\x05\x04\x0e\x02\x03\x01\ + \x12\x04\xf4\x04\x14\x1d\n\r\n\x05\x04\x0e\x02\x03\x03\x12\x04\xf4\x04\ + \x20!\nL\n\x02\x04\x0f\x12\x06\xf8\x04\0\xfb\x04\x01\x1a>\x20The\x20resp\ + onse\x20for\x20[Commit][google.spanner.v1.Spanner.Commit].\n\n\x0b\n\x03\ + \x04\x0f\x01\x12\x04\xf8\x04\x08\x16\nO\n\x04\x04\x0f\x02\0\x12\x04\xfa\ + \x04\x021\x1aA\x20The\x20Cloud\x20Spanner\x20timestamp\x20at\x20which\ + \x20the\x20transaction\x20committed.\n\n\x0f\n\x05\x04\x0f\x02\0\x04\x12\ + \x06\xfa\x04\x02\xf8\x04\x18\n\r\n\x05\x04\x0f\x02\0\x06\x12\x04\xfa\x04\ + \x02\x1b\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\xfa\x04\x1c,\n\r\n\x05\x04\ + \x0f\x02\0\x03\x12\x04\xfa\x04/0\nO\n\x02\x04\x10\x12\x06\xfe\x04\0\x84\ + \x05\x01\x1aA\x20The\x20request\x20for\x20[Rollback][google.spanner.v1.S\ + panner.Rollback].\n\n\x0b\n\x03\x04\x10\x01\x12\x04\xfe\x04\x08\x17\nW\n\ + \x04\x04\x10\x02\0\x12\x04\x80\x05\x02\x15\x1aI\x20Required.\x20The\x20s\ + ession\x20in\x20which\x20the\x20transaction\x20to\x20roll\x20back\x20is\ + \x20running.\n\n\x0f\n\x05\x04\x10\x02\0\x04\x12\x06\x80\x05\x02\xfe\x04\ + \x19\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\x80\x05\x02\x08\n\r\n\x05\x04\ + \x10\x02\0\x01\x12\x04\x80\x05\t\x10\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\ + \x80\x05\x13\x14\n7\n\x04\x04\x10\x02\x01\x12\x04\x83\x05\x02\x1b\x1a)\ + \x20Required.\x20The\x20transaction\x20to\x20roll\x20back.\n\n\x0f\n\x05\ + \x04\x10\x02\x01\x04\x12\x06\x83\x05\x02\x80\x05\x15\n\r\n\x05\x04\x10\ + \x02\x01\x05\x12\x04\x83\x05\x02\x07\n\r\n\x05\x04\x10\x02\x01\x01\x12\ + \x04\x83\x05\x08\x16\n\r\n\x05\x04\x10\x02\x01\x03\x12\x04\x83\x05\x19\ + \x1ab\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner_grpc.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner_grpc.rs new file mode 100644 index 00000000..7d493531 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/spanner_grpc.rs @@ -0,0 +1,391 @@ +// This file is generated. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] + +const METHOD_SPANNER_CREATE_SESSION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/CreateSession", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_GET_SESSION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/GetSession", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_LIST_SESSIONS: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/ListSessions", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_DELETE_SESSION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/DeleteSession", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_EXECUTE_SQL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/ExecuteSql", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_EXECUTE_STREAMING_SQL: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.spanner.v1.Spanner/ExecuteStreamingSql", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_READ: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/Read", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_STREAMING_READ: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::ServerStreaming, + name: "/google.spanner.v1.Spanner/StreamingRead", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_BEGIN_TRANSACTION: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/BeginTransaction", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_COMMIT: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/Commit", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_ROLLBACK: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/Rollback", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_PARTITION_QUERY: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/PartitionQuery", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +const METHOD_SPANNER_PARTITION_READ: ::grpcio::Method = ::grpcio::Method { + ty: ::grpcio::MethodType::Unary, + name: "/google.spanner.v1.Spanner/PartitionRead", + req_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, + resp_mar: ::grpcio::Marshaller { ser: ::grpcio::pb_ser, de: ::grpcio::pb_de }, +}; + +#[derive(Clone)] +pub struct SpannerClient { + client: ::grpcio::Client, +} + +impl SpannerClient { + pub fn new(channel: ::grpcio::Channel) -> Self { + SpannerClient { + client: ::grpcio::Client::new(channel), + } + } + + pub fn create_session_opt(&self, req: &super::spanner::CreateSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_CREATE_SESSION, req, opt) + } + + pub fn create_session(&self, req: &super::spanner::CreateSessionRequest) -> ::grpcio::Result { + self.create_session_opt(req, ::grpcio::CallOption::default()) + } + + pub fn create_session_async_opt(&self, req: &super::spanner::CreateSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_CREATE_SESSION, req, opt) + } + + pub fn create_session_async(&self, req: &super::spanner::CreateSessionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.create_session_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_session_opt(&self, req: &super::spanner::GetSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_GET_SESSION, req, opt) + } + + pub fn get_session(&self, req: &super::spanner::GetSessionRequest) -> ::grpcio::Result { + self.get_session_opt(req, ::grpcio::CallOption::default()) + } + + pub fn get_session_async_opt(&self, req: &super::spanner::GetSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_GET_SESSION, req, opt) + } + + pub fn get_session_async(&self, req: &super::spanner::GetSessionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.get_session_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_sessions_opt(&self, req: &super::spanner::ListSessionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_LIST_SESSIONS, req, opt) + } + + pub fn list_sessions(&self, req: &super::spanner::ListSessionsRequest) -> ::grpcio::Result { + self.list_sessions_opt(req, ::grpcio::CallOption::default()) + } + + pub fn list_sessions_async_opt(&self, req: &super::spanner::ListSessionsRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_LIST_SESSIONS, req, opt) + } + + pub fn list_sessions_async(&self, req: &super::spanner::ListSessionsRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.list_sessions_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_session_opt(&self, req: &super::spanner::DeleteSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_DELETE_SESSION, req, opt) + } + + pub fn delete_session(&self, req: &super::spanner::DeleteSessionRequest) -> ::grpcio::Result { + self.delete_session_opt(req, ::grpcio::CallOption::default()) + } + + pub fn delete_session_async_opt(&self, req: &super::spanner::DeleteSessionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_DELETE_SESSION, req, opt) + } + + pub fn delete_session_async(&self, req: &super::spanner::DeleteSessionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.delete_session_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn execute_sql_opt(&self, req: &super::spanner::ExecuteSqlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_EXECUTE_SQL, req, opt) + } + + pub fn execute_sql(&self, req: &super::spanner::ExecuteSqlRequest) -> ::grpcio::Result { + self.execute_sql_opt(req, ::grpcio::CallOption::default()) + } + + pub fn execute_sql_async_opt(&self, req: &super::spanner::ExecuteSqlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_EXECUTE_SQL, req, opt) + } + + pub fn execute_sql_async(&self, req: &super::spanner::ExecuteSqlRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.execute_sql_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn execute_streaming_sql_opt(&self, req: &super::spanner::ExecuteSqlRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_SPANNER_EXECUTE_STREAMING_SQL, req, opt) + } + + pub fn execute_streaming_sql(&self, req: &super::spanner::ExecuteSqlRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.execute_streaming_sql_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_opt(&self, req: &super::spanner::ReadRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_READ, req, opt) + } + + pub fn read(&self, req: &super::spanner::ReadRequest) -> ::grpcio::Result { + self.read_opt(req, ::grpcio::CallOption::default()) + } + + pub fn read_async_opt(&self, req: &super::spanner::ReadRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_READ, req, opt) + } + + pub fn read_async(&self, req: &super::spanner::ReadRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.read_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn streaming_read_opt(&self, req: &super::spanner::ReadRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.client.server_streaming(&METHOD_SPANNER_STREAMING_READ, req, opt) + } + + pub fn streaming_read(&self, req: &super::spanner::ReadRequest) -> ::grpcio::Result<::grpcio::ClientSStreamReceiver> { + self.streaming_read_opt(req, ::grpcio::CallOption::default()) + } + + pub fn begin_transaction_opt(&self, req: &super::spanner::BeginTransactionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_BEGIN_TRANSACTION, req, opt) + } + + pub fn begin_transaction(&self, req: &super::spanner::BeginTransactionRequest) -> ::grpcio::Result { + self.begin_transaction_opt(req, ::grpcio::CallOption::default()) + } + + pub fn begin_transaction_async_opt(&self, req: &super::spanner::BeginTransactionRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_BEGIN_TRANSACTION, req, opt) + } + + pub fn begin_transaction_async(&self, req: &super::spanner::BeginTransactionRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.begin_transaction_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn commit_opt(&self, req: &super::spanner::CommitRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_COMMIT, req, opt) + } + + pub fn commit(&self, req: &super::spanner::CommitRequest) -> ::grpcio::Result { + self.commit_opt(req, ::grpcio::CallOption::default()) + } + + pub fn commit_async_opt(&self, req: &super::spanner::CommitRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_COMMIT, req, opt) + } + + pub fn commit_async(&self, req: &super::spanner::CommitRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.commit_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn rollback_opt(&self, req: &super::spanner::RollbackRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_ROLLBACK, req, opt) + } + + pub fn rollback(&self, req: &super::spanner::RollbackRequest) -> ::grpcio::Result { + self.rollback_opt(req, ::grpcio::CallOption::default()) + } + + pub fn rollback_async_opt(&self, req: &super::spanner::RollbackRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_ROLLBACK, req, opt) + } + + pub fn rollback_async(&self, req: &super::spanner::RollbackRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.rollback_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partition_query_opt(&self, req: &super::spanner::PartitionQueryRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_PARTITION_QUERY, req, opt) + } + + pub fn partition_query(&self, req: &super::spanner::PartitionQueryRequest) -> ::grpcio::Result { + self.partition_query_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partition_query_async_opt(&self, req: &super::spanner::PartitionQueryRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_PARTITION_QUERY, req, opt) + } + + pub fn partition_query_async(&self, req: &super::spanner::PartitionQueryRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.partition_query_async_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partition_read_opt(&self, req: &super::spanner::PartitionReadRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result { + self.client.unary_call(&METHOD_SPANNER_PARTITION_READ, req, opt) + } + + pub fn partition_read(&self, req: &super::spanner::PartitionReadRequest) -> ::grpcio::Result { + self.partition_read_opt(req, ::grpcio::CallOption::default()) + } + + pub fn partition_read_async_opt(&self, req: &super::spanner::PartitionReadRequest, opt: ::grpcio::CallOption) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.client.unary_call_async(&METHOD_SPANNER_PARTITION_READ, req, opt) + } + + pub fn partition_read_async(&self, req: &super::spanner::PartitionReadRequest) -> ::grpcio::Result<::grpcio::ClientUnaryReceiver> { + self.partition_read_async_opt(req, ::grpcio::CallOption::default()) + } + pub fn spawn(&self, f: F) where F: ::futures::Future + Send + 'static { + self.client.spawn(f) + } +} + +pub trait Spanner { + fn create_session(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::CreateSessionRequest, sink: ::grpcio::UnarySink); + fn get_session(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::GetSessionRequest, sink: ::grpcio::UnarySink); + fn list_sessions(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::ListSessionsRequest, sink: ::grpcio::UnarySink); + fn delete_session(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::DeleteSessionRequest, sink: ::grpcio::UnarySink); + fn execute_sql(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::ExecuteSqlRequest, sink: ::grpcio::UnarySink); + fn execute_streaming_sql(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::ExecuteSqlRequest, sink: ::grpcio::ServerStreamingSink); + fn read(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::ReadRequest, sink: ::grpcio::UnarySink); + fn streaming_read(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::ReadRequest, sink: ::grpcio::ServerStreamingSink); + fn begin_transaction(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::BeginTransactionRequest, sink: ::grpcio::UnarySink); + fn commit(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::CommitRequest, sink: ::grpcio::UnarySink); + fn rollback(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::RollbackRequest, sink: ::grpcio::UnarySink); + fn partition_query(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::PartitionQueryRequest, sink: ::grpcio::UnarySink); + fn partition_read(&mut self, ctx: ::grpcio::RpcContext, req: super::spanner::PartitionReadRequest, sink: ::grpcio::UnarySink); +} + +pub fn create_spanner(s: S) -> ::grpcio::Service { + let mut builder = ::grpcio::ServiceBuilder::new(); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_CREATE_SESSION, move |ctx, req, resp| { + instance.create_session(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_GET_SESSION, move |ctx, req, resp| { + instance.get_session(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_LIST_SESSIONS, move |ctx, req, resp| { + instance.list_sessions(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_DELETE_SESSION, move |ctx, req, resp| { + instance.delete_session(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_EXECUTE_SQL, move |ctx, req, resp| { + instance.execute_sql(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_SPANNER_EXECUTE_STREAMING_SQL, move |ctx, req, resp| { + instance.execute_streaming_sql(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_READ, move |ctx, req, resp| { + instance.read(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_server_streaming_handler(&METHOD_SPANNER_STREAMING_READ, move |ctx, req, resp| { + instance.streaming_read(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_BEGIN_TRANSACTION, move |ctx, req, resp| { + instance.begin_transaction(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_COMMIT, move |ctx, req, resp| { + instance.commit(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_ROLLBACK, move |ctx, req, resp| { + instance.rollback(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_PARTITION_QUERY, move |ctx, req, resp| { + instance.partition_query(ctx, req, resp) + }); + let mut instance = s.clone(); + builder = builder.add_unary_handler(&METHOD_SPANNER_PARTITION_READ, move |ctx, req, resp| { + instance.partition_read(ctx, req, resp) + }); + builder.build() +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/transaction.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/transaction.rs new file mode 100644 index 00000000..382adea0 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/transaction.rs @@ -0,0 +1,2245 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/transaction.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct TransactionOptions { + // message oneof groups + pub mode: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TransactionOptions { + fn default() -> &'a TransactionOptions { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum TransactionOptions_oneof_mode { + read_write(TransactionOptions_ReadWrite), + partitioned_dml(TransactionOptions_PartitionedDml), + read_only(TransactionOptions_ReadOnly), +} + +impl TransactionOptions { + pub fn new() -> TransactionOptions { + ::std::default::Default::default() + } + + // .google.spanner.v1.TransactionOptions.ReadWrite read_write = 1; + + + pub fn get_read_write(&self) -> &TransactionOptions_ReadWrite { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(ref v)) => v, + _ => TransactionOptions_ReadWrite::default_instance(), + } + } + pub fn clear_read_write(&mut self) { + self.mode = ::std::option::Option::None; + } + + pub fn has_read_write(&self) -> bool { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_read_write(&mut self, v: TransactionOptions_ReadWrite) { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(v)) + } + + // Mutable pointer to the field. + pub fn mut_read_write(&mut self) -> &mut TransactionOptions_ReadWrite { + if let ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(_)) = self.mode { + } else { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(TransactionOptions_ReadWrite::new())); + } + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_read_write(&mut self) -> TransactionOptions_ReadWrite { + if self.has_read_write() { + match self.mode.take() { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(v)) => v, + _ => panic!(), + } + } else { + TransactionOptions_ReadWrite::new() + } + } + + // .google.spanner.v1.TransactionOptions.PartitionedDml partitioned_dml = 3; + + + pub fn get_partitioned_dml(&self) -> &TransactionOptions_PartitionedDml { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(ref v)) => v, + _ => TransactionOptions_PartitionedDml::default_instance(), + } + } + pub fn clear_partitioned_dml(&mut self) { + self.mode = ::std::option::Option::None; + } + + pub fn has_partitioned_dml(&self) -> bool { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_partitioned_dml(&mut self, v: TransactionOptions_PartitionedDml) { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(v)) + } + + // Mutable pointer to the field. + pub fn mut_partitioned_dml(&mut self) -> &mut TransactionOptions_PartitionedDml { + if let ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(_)) = self.mode { + } else { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(TransactionOptions_PartitionedDml::new())); + } + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_partitioned_dml(&mut self) -> TransactionOptions_PartitionedDml { + if self.has_partitioned_dml() { + match self.mode.take() { + ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(v)) => v, + _ => panic!(), + } + } else { + TransactionOptions_PartitionedDml::new() + } + } + + // .google.spanner.v1.TransactionOptions.ReadOnly read_only = 2; + + + pub fn get_read_only(&self) -> &TransactionOptions_ReadOnly { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(ref v)) => v, + _ => TransactionOptions_ReadOnly::default_instance(), + } + } + pub fn clear_read_only(&mut self) { + self.mode = ::std::option::Option::None; + } + + pub fn has_read_only(&self) -> bool { + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_read_only(&mut self, v: TransactionOptions_ReadOnly) { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(v)) + } + + // Mutable pointer to the field. + pub fn mut_read_only(&mut self) -> &mut TransactionOptions_ReadOnly { + if let ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(_)) = self.mode { + } else { + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(TransactionOptions_ReadOnly::new())); + } + match self.mode { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_read_only(&mut self) -> TransactionOptions_ReadOnly { + if self.has_read_only() { + match self.mode.take() { + ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(v)) => v, + _ => panic!(), + } + } else { + TransactionOptions_ReadOnly::new() + } + } +} + +impl ::protobuf::Message for TransactionOptions { + fn is_initialized(&self) -> bool { + if let Some(TransactionOptions_oneof_mode::read_write(ref v)) = self.mode { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionOptions_oneof_mode::partitioned_dml(ref v)) = self.mode { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionOptions_oneof_mode::read_only(ref v)) = self.mode { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_write(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::partitioned_dml(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.mode = ::std::option::Option::Some(TransactionOptions_oneof_mode::read_only(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.mode { + match v { + &TransactionOptions_oneof_mode::read_write(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionOptions_oneof_mode::partitioned_dml(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionOptions_oneof_mode::read_only(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.mode { + match v { + &TransactionOptions_oneof_mode::read_write(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionOptions_oneof_mode::partitioned_dml(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionOptions_oneof_mode::read_only(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TransactionOptions { + TransactionOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_ReadWrite>( + "read_write", + TransactionOptions::has_read_write, + TransactionOptions::get_read_write, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_PartitionedDml>( + "partitioned_dml", + TransactionOptions::has_partitioned_dml, + TransactionOptions::get_partitioned_dml, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions_ReadOnly>( + "read_only", + TransactionOptions::has_read_only, + TransactionOptions::get_read_only, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TransactionOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TransactionOptions { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TransactionOptions, + }; + unsafe { + instance.get(TransactionOptions::new) + } + } +} + +impl ::protobuf::Clear for TransactionOptions { + fn clear(&mut self) { + self.mode = ::std::option::Option::None; + self.mode = ::std::option::Option::None; + self.mode = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TransactionOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TransactionOptions { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TransactionOptions_ReadWrite { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TransactionOptions_ReadWrite { + fn default() -> &'a TransactionOptions_ReadWrite { + ::default_instance() + } +} + +impl TransactionOptions_ReadWrite { + pub fn new() -> TransactionOptions_ReadWrite { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for TransactionOptions_ReadWrite { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TransactionOptions_ReadWrite { + TransactionOptions_ReadWrite::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "TransactionOptions_ReadWrite", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TransactionOptions_ReadWrite { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TransactionOptions_ReadWrite, + }; + unsafe { + instance.get(TransactionOptions_ReadWrite::new) + } + } +} + +impl ::protobuf::Clear for TransactionOptions_ReadWrite { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TransactionOptions_ReadWrite { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TransactionOptions_ReadWrite { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TransactionOptions_PartitionedDml { + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TransactionOptions_PartitionedDml { + fn default() -> &'a TransactionOptions_PartitionedDml { + ::default_instance() + } +} + +impl TransactionOptions_PartitionedDml { + pub fn new() -> TransactionOptions_PartitionedDml { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for TransactionOptions_PartitionedDml { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TransactionOptions_PartitionedDml { + TransactionOptions_PartitionedDml::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new::( + "TransactionOptions_PartitionedDml", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TransactionOptions_PartitionedDml { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TransactionOptions_PartitionedDml, + }; + unsafe { + instance.get(TransactionOptions_PartitionedDml::new) + } + } +} + +impl ::protobuf::Clear for TransactionOptions_PartitionedDml { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TransactionOptions_PartitionedDml { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TransactionOptions_PartitionedDml { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TransactionOptions_ReadOnly { + // message fields + pub return_read_timestamp: bool, + // message oneof groups + pub timestamp_bound: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TransactionOptions_ReadOnly { + fn default() -> &'a TransactionOptions_ReadOnly { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum TransactionOptions_ReadOnly_oneof_timestamp_bound { + strong(bool), + min_read_timestamp(::protobuf::well_known_types::Timestamp), + max_staleness(::protobuf::well_known_types::Duration), + read_timestamp(::protobuf::well_known_types::Timestamp), + exact_staleness(::protobuf::well_known_types::Duration), +} + +impl TransactionOptions_ReadOnly { + pub fn new() -> TransactionOptions_ReadOnly { + ::std::default::Default::default() + } + + // bool strong = 1; + + + pub fn get_strong(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v)) => v, + _ => false, + } + } + pub fn clear_strong(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + } + + pub fn has_strong(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_strong(&mut self, v: bool) { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v)) + } + + // .google.protobuf.Timestamp min_read_timestamp = 2; + + + pub fn get_min_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v)) => v, + _ => ::protobuf::well_known_types::Timestamp::default_instance(), + } + } + pub fn clear_min_read_timestamp(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + } + + pub fn has_min_read_timestamp(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_min_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(v)) + } + + // Mutable pointer to the field. + pub fn mut_min_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(_)) = self.timestamp_bound { + } else { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(::protobuf::well_known_types::Timestamp::new())); + } + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_min_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp { + if self.has_min_read_timestamp() { + match self.timestamp_bound.take() { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Timestamp::new() + } + } + + // .google.protobuf.Duration max_staleness = 3; + + + pub fn get_max_staleness(&self) -> &::protobuf::well_known_types::Duration { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v)) => v, + _ => ::protobuf::well_known_types::Duration::default_instance(), + } + } + pub fn clear_max_staleness(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + } + + pub fn has_max_staleness(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_max_staleness(&mut self, v: ::protobuf::well_known_types::Duration) { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(v)) + } + + // Mutable pointer to the field. + pub fn mut_max_staleness(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(_)) = self.timestamp_bound { + } else { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(::protobuf::well_known_types::Duration::new())); + } + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_max_staleness(&mut self) -> ::protobuf::well_known_types::Duration { + if self.has_max_staleness() { + match self.timestamp_bound.take() { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Duration::new() + } + } + + // .google.protobuf.Timestamp read_timestamp = 4; + + + pub fn get_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v)) => v, + _ => ::protobuf::well_known_types::Timestamp::default_instance(), + } + } + pub fn clear_read_timestamp(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + } + + pub fn has_read_timestamp(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(v)) + } + + // Mutable pointer to the field. + pub fn mut_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(_)) = self.timestamp_bound { + } else { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(::protobuf::well_known_types::Timestamp::new())); + } + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp { + if self.has_read_timestamp() { + match self.timestamp_bound.take() { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Timestamp::new() + } + } + + // .google.protobuf.Duration exact_staleness = 5; + + + pub fn get_exact_staleness(&self) -> &::protobuf::well_known_types::Duration { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v)) => v, + _ => ::protobuf::well_known_types::Duration::default_instance(), + } + } + pub fn clear_exact_staleness(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + } + + pub fn has_exact_staleness(&self) -> bool { + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_exact_staleness(&mut self, v: ::protobuf::well_known_types::Duration) { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(v)) + } + + // Mutable pointer to the field. + pub fn mut_exact_staleness(&mut self) -> &mut ::protobuf::well_known_types::Duration { + if let ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(_)) = self.timestamp_bound { + } else { + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(::protobuf::well_known_types::Duration::new())); + } + match self.timestamp_bound { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_exact_staleness(&mut self) -> ::protobuf::well_known_types::Duration { + if self.has_exact_staleness() { + match self.timestamp_bound.take() { + ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(v)) => v, + _ => panic!(), + } + } else { + ::protobuf::well_known_types::Duration::new() + } + } + + // bool return_read_timestamp = 6; + + + pub fn get_return_read_timestamp(&self) -> bool { + self.return_read_timestamp + } + pub fn clear_return_read_timestamp(&mut self) { + self.return_read_timestamp = false; + } + + // Param is passed by value, moved + pub fn set_return_read_timestamp(&mut self, v: bool) { + self.return_read_timestamp = v; + } +} + +impl ::protobuf::Message for TransactionOptions_ReadOnly { + fn is_initialized(&self) -> bool { + if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v)) = self.timestamp_bound { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v)) = self.timestamp_bound { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v)) = self.timestamp_bound { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v)) = self.timestamp_bound { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(is.read_bool()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(is.read_message()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(is.read_message()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(is.read_message()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.timestamp_bound = ::std::option::Option::Some(TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(is.read_message()?)); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.return_read_timestamp = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.return_read_timestamp != false { + my_size += 2; + } + if let ::std::option::Option::Some(ref v) = self.timestamp_bound { + match v { + &TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v) => { + my_size += 2; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.return_read_timestamp != false { + os.write_bool(6, self.return_read_timestamp)?; + } + if let ::std::option::Option::Some(ref v) = self.timestamp_bound { + match v { + &TransactionOptions_ReadOnly_oneof_timestamp_bound::strong(v) => { + os.write_bool(1, v)?; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::min_read_timestamp(ref v) => { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::max_staleness(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::read_timestamp(ref v) => { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionOptions_ReadOnly_oneof_timestamp_bound::exact_staleness(ref v) => { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TransactionOptions_ReadOnly { + TransactionOptions_ReadOnly::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "strong", + TransactionOptions_ReadOnly::has_strong, + TransactionOptions_ReadOnly::get_strong, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Timestamp>( + "min_read_timestamp", + TransactionOptions_ReadOnly::has_min_read_timestamp, + TransactionOptions_ReadOnly::get_min_read_timestamp, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>( + "max_staleness", + TransactionOptions_ReadOnly::has_max_staleness, + TransactionOptions_ReadOnly::get_max_staleness, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Timestamp>( + "read_timestamp", + TransactionOptions_ReadOnly::has_read_timestamp, + TransactionOptions_ReadOnly::get_read_timestamp, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ::protobuf::well_known_types::Duration>( + "exact_staleness", + TransactionOptions_ReadOnly::has_exact_staleness, + TransactionOptions_ReadOnly::get_exact_staleness, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "return_read_timestamp", + |m: &TransactionOptions_ReadOnly| { &m.return_read_timestamp }, + |m: &mut TransactionOptions_ReadOnly| { &mut m.return_read_timestamp }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TransactionOptions_ReadOnly", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TransactionOptions_ReadOnly { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TransactionOptions_ReadOnly, + }; + unsafe { + instance.get(TransactionOptions_ReadOnly::new) + } + } +} + +impl ::protobuf::Clear for TransactionOptions_ReadOnly { + fn clear(&mut self) { + self.timestamp_bound = ::std::option::Option::None; + self.timestamp_bound = ::std::option::Option::None; + self.timestamp_bound = ::std::option::Option::None; + self.timestamp_bound = ::std::option::Option::None; + self.timestamp_bound = ::std::option::Option::None; + self.return_read_timestamp = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TransactionOptions_ReadOnly { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TransactionOptions_ReadOnly { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct Transaction { + // message fields + pub id: ::std::vec::Vec, + pub read_timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Transaction { + fn default() -> &'a Transaction { + ::default_instance() + } +} + +impl Transaction { + pub fn new() -> Transaction { + ::std::default::Default::default() + } + + // bytes id = 1; + + + pub fn get_id(&self) -> &[u8] { + &self.id + } + pub fn clear_id(&mut self) { + self.id.clear(); + } + + // Param is passed by value, moved + pub fn set_id(&mut self, v: ::std::vec::Vec) { + self.id = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_id(&mut self) -> &mut ::std::vec::Vec { + &mut self.id + } + + // Take field + pub fn take_id(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.id, ::std::vec::Vec::new()) + } + + // .google.protobuf.Timestamp read_timestamp = 2; + + + pub fn get_read_timestamp(&self) -> &::protobuf::well_known_types::Timestamp { + self.read_timestamp.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance()) + } + pub fn clear_read_timestamp(&mut self) { + self.read_timestamp.clear(); + } + + pub fn has_read_timestamp(&self) -> bool { + self.read_timestamp.is_some() + } + + // Param is passed by value, moved + pub fn set_read_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) { + self.read_timestamp = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_read_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp { + if self.read_timestamp.is_none() { + self.read_timestamp.set_default(); + } + self.read_timestamp.as_mut().unwrap() + } + + // Take field + pub fn take_read_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp { + self.read_timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new()) + } +} + +impl ::protobuf::Message for Transaction { + fn is_initialized(&self) -> bool { + for v in &self.read_timestamp { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.id)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.read_timestamp)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.id.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.id); + } + if let Some(ref v) = self.read_timestamp.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.id.is_empty() { + os.write_bytes(1, &self.id)?; + } + if let Some(ref v) = self.read_timestamp.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Transaction { + Transaction::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "id", + |m: &Transaction| { &m.id }, + |m: &mut Transaction| { &mut m.id }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>( + "read_timestamp", + |m: &Transaction| { &m.read_timestamp }, + |m: &mut Transaction| { &mut m.read_timestamp }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Transaction", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Transaction { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Transaction, + }; + unsafe { + instance.get(Transaction::new) + } + } +} + +impl ::protobuf::Clear for Transaction { + fn clear(&mut self) { + self.id.clear(); + self.read_timestamp.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Transaction { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Transaction { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct TransactionSelector { + // message oneof groups + pub selector: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a TransactionSelector { + fn default() -> &'a TransactionSelector { + ::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +pub enum TransactionSelector_oneof_selector { + single_use(TransactionOptions), + id(::std::vec::Vec), + begin(TransactionOptions), +} + +impl TransactionSelector { + pub fn new() -> TransactionSelector { + ::std::default::Default::default() + } + + // .google.spanner.v1.TransactionOptions single_use = 1; + + + pub fn get_single_use(&self) -> &TransactionOptions { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(ref v)) => v, + _ => TransactionOptions::default_instance(), + } + } + pub fn clear_single_use(&mut self) { + self.selector = ::std::option::Option::None; + } + + pub fn has_single_use(&self) -> bool { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_single_use(&mut self, v: TransactionOptions) { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(v)) + } + + // Mutable pointer to the field. + pub fn mut_single_use(&mut self) -> &mut TransactionOptions { + if let ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(_)) = self.selector { + } else { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(TransactionOptions::new())); + } + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_single_use(&mut self) -> TransactionOptions { + if self.has_single_use() { + match self.selector.take() { + ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(v)) => v, + _ => panic!(), + } + } else { + TransactionOptions::new() + } + } + + // bytes id = 2; + + + pub fn get_id(&self) -> &[u8] { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::id(ref v)) => v, + _ => &[], + } + } + pub fn clear_id(&mut self) { + self.selector = ::std::option::Option::None; + } + + pub fn has_id(&self) -> bool { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::id(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_id(&mut self, v: ::std::vec::Vec) { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(v)) + } + + // Mutable pointer to the field. + pub fn mut_id(&mut self) -> &mut ::std::vec::Vec { + if let ::std::option::Option::Some(TransactionSelector_oneof_selector::id(_)) = self.selector { + } else { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(::std::vec::Vec::new())); + } + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::id(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_id(&mut self) -> ::std::vec::Vec { + if self.has_id() { + match self.selector.take() { + ::std::option::Option::Some(TransactionSelector_oneof_selector::id(v)) => v, + _ => panic!(), + } + } else { + ::std::vec::Vec::new() + } + } + + // .google.spanner.v1.TransactionOptions begin = 3; + + + pub fn get_begin(&self) -> &TransactionOptions { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(ref v)) => v, + _ => TransactionOptions::default_instance(), + } + } + pub fn clear_begin(&mut self) { + self.selector = ::std::option::Option::None; + } + + pub fn has_begin(&self) -> bool { + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_begin(&mut self, v: TransactionOptions) { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(v)) + } + + // Mutable pointer to the field. + pub fn mut_begin(&mut self) -> &mut TransactionOptions { + if let ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(_)) = self.selector { + } else { + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(TransactionOptions::new())); + } + match self.selector { + ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_begin(&mut self) -> TransactionOptions { + if self.has_begin() { + match self.selector.take() { + ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(v)) => v, + _ => panic!(), + } + } else { + TransactionOptions::new() + } + } +} + +impl ::protobuf::Message for TransactionSelector { + fn is_initialized(&self) -> bool { + if let Some(TransactionSelector_oneof_selector::single_use(ref v)) = self.selector { + if !v.is_initialized() { + return false; + } + } + if let Some(TransactionSelector_oneof_selector::begin(ref v)) = self.selector { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::single_use(is.read_message()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::id(is.read_bytes()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.selector = ::std::option::Option::Some(TransactionSelector_oneof_selector::begin(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.selector { + match v { + &TransactionSelector_oneof_selector::single_use(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &TransactionSelector_oneof_selector::id(ref v) => { + my_size += ::protobuf::rt::bytes_size(2, &v); + }, + &TransactionSelector_oneof_selector::begin(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.selector { + match v { + &TransactionSelector_oneof_selector::single_use(ref v) => { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &TransactionSelector_oneof_selector::id(ref v) => { + os.write_bytes(2, v)?; + }, + &TransactionSelector_oneof_selector::begin(ref v) => { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> TransactionSelector { + TransactionSelector::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions>( + "single_use", + TransactionSelector::has_single_use, + TransactionSelector::get_single_use, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>( + "id", + TransactionSelector::has_id, + TransactionSelector::get_id, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, TransactionOptions>( + "begin", + TransactionSelector::has_begin, + TransactionSelector::get_begin, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "TransactionSelector", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static TransactionSelector { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const TransactionSelector, + }; + unsafe { + instance.get(TransactionSelector::new) + } + } +} + +impl ::protobuf::Clear for TransactionSelector { + fn clear(&mut self) { + self.selector = ::std::option::Option::None; + self.selector = ::std::option::Option::None; + self.selector = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TransactionSelector { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for TransactionSelector { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n#google/spanner/v1/transaction.proto\x12\x11google.spanner.v1\x1a\x1cg\ + oogle/api/annotations.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\ + \x1fgoogle/protobuf/timestamp.proto\"\xc4\x05\n\x12TransactionOptions\ + \x12P\n\nread_write\x18\x01\x20\x01(\x0b2/.google.spanner.v1.Transaction\ + Options.ReadWriteH\0R\treadWrite\x12_\n\x0fpartitioned_dml\x18\x03\x20\ + \x01(\x0b24.google.spanner.v1.TransactionOptions.PartitionedDmlH\0R\x0ep\ + artitionedDml\x12M\n\tread_only\x18\x02\x20\x01(\x0b2..google.spanner.v1\ + .TransactionOptions.ReadOnlyH\0R\x08readOnly\x1a\x0b\n\tReadWrite\x1a\ + \x10\n\x0ePartitionedDml\x1a\x84\x03\n\x08ReadOnly\x12\x18\n\x06strong\ + \x18\x01\x20\x01(\x08H\0R\x06strong\x12J\n\x12min_read_timestamp\x18\x02\ + \x20\x01(\x0b2\x1a.google.protobuf.TimestampH\0R\x10minReadTimestamp\x12\ + @\n\rmax_staleness\x18\x03\x20\x01(\x0b2\x19.google.protobuf.DurationH\0\ + R\x0cmaxStaleness\x12C\n\x0eread_timestamp\x18\x04\x20\x01(\x0b2\x1a.goo\ + gle.protobuf.TimestampH\0R\rreadTimestamp\x12D\n\x0fexact_staleness\x18\ + \x05\x20\x01(\x0b2\x19.google.protobuf.DurationH\0R\x0eexactStaleness\ + \x122\n\x15return_read_timestamp\x18\x06\x20\x01(\x08R\x13returnReadTime\ + stampB\x11\n\x0ftimestamp_boundB\x06\n\x04mode\"`\n\x0bTransaction\x12\ + \x0e\n\x02id\x18\x01\x20\x01(\x0cR\x02id\x12A\n\x0eread_timestamp\x18\ + \x02\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\rreadTimestamp\"\xba\ + \x01\n\x13TransactionSelector\x12F\n\nsingle_use\x18\x01\x20\x01(\x0b2%.\ + google.spanner.v1.TransactionOptionsH\0R\tsingleUse\x12\x10\n\x02id\x18\ + \x02\x20\x01(\x0cH\0R\x02id\x12=\n\x05begin\x18\x03\x20\x01(\x0b2%.googl\ + e.spanner.v1.TransactionOptionsH\0R\x05beginB\n\n\x08selectorB\x99\x01\n\ + \x15com.google.spanner.v1B\x10TransactionProtoP\x01Z8google.golang.org/g\ + enproto/googleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V1\ + \xca\x02\x17Google\\Cloud\\Spanner\\V1J\xce\x99\x01\n\x07\x12\x05\x0e\0\ + \xc7\x03\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\ + \x202018\x20Google\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apache\x20L\ + icense,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20no\ + t\x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\ + \x20License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20Lice\ + nse\x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-\ + 2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\ + \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\ + \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\ + \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\ + ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\ + the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\ + tations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\ + \n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0(\n\t\n\ + \x02\x03\x02\x12\x03\x14\0)\n\x08\n\x01\x08\x12\x03\x16\04\n\t\n\x02\x08\ + %\x12\x03\x16\04\n\x08\n\x01\x08\x12\x03\x17\0O\n\t\n\x02\x08\x0b\x12\ + \x03\x17\0O\n\x08\n\x01\x08\x12\x03\x18\0\"\n\t\n\x02\x08\n\x12\x03\x18\ + \0\"\n\x08\n\x01\x08\x12\x03\x19\01\n\t\n\x02\x08\x08\x12\x03\x19\01\n\ + \x08\n\x01\x08\x12\x03\x1a\0.\n\t\n\x02\x08\x01\x12\x03\x1a\0.\n\x08\n\ + \x01\x08\x12\x03\x1b\04\n\t\n\x02\x08)\x12\x03\x1b\04\n\x80e\n\x02\x04\0\ + \x12\x06\xb3\x02\0\x9a\x03\x01\x1a\xf1d\x20#\x20Transactions\n\n\n\x20Ea\ + ch\x20session\x20can\x20have\x20at\x20most\x20one\x20active\x20transacti\ + on\x20at\x20a\x20time.\x20After\x20the\n\x20active\x20transaction\x20is\ + \x20completed,\x20the\x20session\x20can\x20immediately\x20be\n\x20re-use\ + d\x20for\x20the\x20next\x20transaction.\x20It\x20is\x20not\x20necessary\ + \x20to\x20create\x20a\n\x20new\x20session\x20for\x20each\x20transaction.\ + \n\n\x20#\x20Transaction\x20Modes\n\n\x20Cloud\x20Spanner\x20supports\ + \x20three\x20transaction\x20modes:\n\n\x20\x20\x201.\x20Locking\x20read-\ + write.\x20This\x20type\x20of\x20transaction\x20is\x20the\x20only\x20way\ + \n\x20\x20\x20\x20\x20\x20to\x20write\x20data\x20into\x20Cloud\x20Spanne\ + r.\x20These\x20transactions\x20rely\x20on\n\x20\x20\x20\x20\x20\x20pessi\ + mistic\x20locking\x20and,\x20if\x20necessary,\x20two-phase\x20commit.\n\ + \x20\x20\x20\x20\x20\x20Locking\x20read-write\x20transactions\x20may\x20\ + abort,\x20requiring\x20the\n\x20\x20\x20\x20\x20\x20application\x20to\ + \x20retry.\n\n\x20\x20\x202.\x20Snapshot\x20read-only.\x20This\x20transa\ + ction\x20type\x20provides\x20guaranteed\n\x20\x20\x20\x20\x20\x20consist\ + ency\x20across\x20several\x20reads,\x20but\x20does\x20not\x20allow\n\x20\ + \x20\x20\x20\x20\x20writes.\x20Snapshot\x20read-only\x20transactions\x20\ + can\x20be\x20configured\x20to\n\x20\x20\x20\x20\x20\x20read\x20at\x20tim\ + estamps\x20in\x20the\x20past.\x20Snapshot\x20read-only\n\x20\x20\x20\x20\ + \x20\x20transactions\x20do\x20not\x20need\x20to\x20be\x20committed.\n\n\ + \x20\x20\x203.\x20Partitioned\x20DML.\x20This\x20type\x20of\x20transacti\ + on\x20is\x20used\x20to\x20execute\n\x20\x20\x20\x20\x20\x20a\x20single\ + \x20Partitioned\x20DML\x20statement.\x20Partitioned\x20DML\x20partitions\ + \n\x20\x20\x20\x20\x20\x20the\x20key\x20space\x20and\x20runs\x20the\x20D\ + ML\x20statement\x20over\x20each\x20partition\n\x20\x20\x20\x20\x20\x20in\ + \x20parallel\x20using\x20separate,\x20internal\x20transactions\x20that\ + \x20commit\n\x20\x20\x20\x20\x20\x20independently.\x20Partitioned\x20DML\ + \x20transactions\x20do\x20not\x20need\x20to\x20be\n\x20\x20\x20\x20\x20\ + \x20committed.\n\n\x20For\x20transactions\x20that\x20only\x20read,\x20sn\ + apshot\x20read-only\x20transactions\n\x20provide\x20simpler\x20semantics\ + \x20and\x20are\x20almost\x20always\x20faster.\x20In\n\x20particular,\x20\ + read-only\x20transactions\x20do\x20not\x20take\x20locks,\x20so\x20they\ + \x20do\n\x20not\x20conflict\x20with\x20read-write\x20transactions.\x20As\ + \x20a\x20consequence\x20of\x20not\n\x20taking\x20locks,\x20they\x20also\ + \x20do\x20not\x20abort,\x20so\x20retry\x20loops\x20are\x20not\x20needed.\ + \n\n\x20Transactions\x20may\x20only\x20read/write\x20data\x20in\x20a\x20\ + single\x20database.\x20They\n\x20may,\x20however,\x20read/write\x20data\ + \x20in\x20different\x20tables\x20within\x20that\n\x20database.\n\n\x20##\ + \x20Locking\x20Read-Write\x20Transactions\n\n\x20Locking\x20transactions\ + \x20may\x20be\x20used\x20to\x20atomically\x20read-modify-write\n\x20data\ + \x20anywhere\x20in\x20a\x20database.\x20This\x20type\x20of\x20transactio\ + n\x20is\x20externally\n\x20consistent.\n\n\x20Clients\x20should\x20attem\ + pt\x20to\x20minimize\x20the\x20amount\x20of\x20time\x20a\x20transaction\ + \n\x20is\x20active.\x20Faster\x20transactions\x20commit\x20with\x20highe\ + r\x20probability\n\x20and\x20cause\x20less\x20contention.\x20Cloud\x20Sp\ + anner\x20attempts\x20to\x20keep\x20read\x20locks\n\x20active\x20as\x20lo\ + ng\x20as\x20the\x20transaction\x20continues\x20to\x20do\x20reads,\x20and\ + \x20the\n\x20transaction\x20has\x20not\x20been\x20terminated\x20by\n\x20\ + [Commit][google.spanner.v1.Spanner.Commit]\x20or\n\x20[Rollback][google.\ + spanner.v1.Spanner.Rollback].\x20\x20Long\x20periods\x20of\n\x20inactivi\ + ty\x20at\x20the\x20client\x20may\x20cause\x20Cloud\x20Spanner\x20to\x20r\ + elease\x20a\n\x20transaction's\x20locks\x20and\x20abort\x20it.\n\n\x20Co\ + nceptually,\x20a\x20read-write\x20transaction\x20consists\x20of\x20zero\ + \x20or\x20more\n\x20reads\x20or\x20SQL\x20statements\x20followed\x20by\n\ + \x20[Commit][google.spanner.v1.Spanner.Commit].\x20At\x20any\x20time\x20\ + before\n\x20[Commit][google.spanner.v1.Spanner.Commit],\x20the\x20client\ + \x20can\x20send\x20a\n\x20[Rollback][google.spanner.v1.Spanner.Rollback]\ + \x20request\x20to\x20abort\x20the\n\x20transaction.\n\n\x20###\x20Semant\ + ics\n\n\x20Cloud\x20Spanner\x20can\x20commit\x20the\x20transaction\x20if\ + \x20all\x20read\x20locks\x20it\x20acquired\n\x20are\x20still\x20valid\ + \x20at\x20commit\x20time,\x20and\x20it\x20is\x20able\x20to\x20acquire\ + \x20write\n\x20locks\x20for\x20all\x20writes.\x20Cloud\x20Spanner\x20can\ + \x20abort\x20the\x20transaction\x20for\x20any\n\x20reason.\x20If\x20a\ + \x20commit\x20attempt\x20returns\x20`ABORTED`,\x20Cloud\x20Spanner\x20gu\ + arantees\n\x20that\x20the\x20transaction\x20has\x20not\x20modified\x20an\ + y\x20user\x20data\x20in\x20Cloud\x20Spanner.\n\n\x20Unless\x20the\x20tra\ + nsaction\x20commits,\x20Cloud\x20Spanner\x20makes\x20no\x20guarantees\ + \x20about\n\x20how\x20long\x20the\x20transaction's\x20locks\x20were\x20h\ + eld\x20for.\x20It\x20is\x20an\x20error\x20to\n\x20use\x20Cloud\x20Spanne\ + r\x20locks\x20for\x20any\x20sort\x20of\x20mutual\x20exclusion\x20other\ + \x20than\n\x20between\x20Cloud\x20Spanner\x20transactions\x20themselves.\ + \n\n\x20###\x20Retrying\x20Aborted\x20Transactions\n\n\x20When\x20a\x20t\ + ransaction\x20aborts,\x20the\x20application\x20can\x20choose\x20to\x20re\ + try\x20the\n\x20whole\x20transaction\x20again.\x20To\x20maximize\x20the\ + \x20chances\x20of\x20successfully\n\x20committing\x20the\x20retry,\x20th\ + e\x20client\x20should\x20execute\x20the\x20retry\x20in\x20the\n\x20same\ + \x20session\x20as\x20the\x20original\x20attempt.\x20The\x20original\x20s\ + ession's\x20lock\n\x20priority\x20increases\x20with\x20each\x20consecuti\ + ve\x20abort,\x20meaning\x20that\x20each\n\x20attempt\x20has\x20a\x20slig\ + htly\x20better\x20chance\x20of\x20success\x20than\x20the\x20previous.\n\ + \n\x20Under\x20some\x20circumstances\x20(e.g.,\x20many\x20transactions\ + \x20attempting\x20to\n\x20modify\x20the\x20same\x20row(s)),\x20a\x20tran\ + saction\x20can\x20abort\x20many\x20times\x20in\x20a\n\x20short\x20period\ + \x20before\x20successfully\x20committing.\x20Thus,\x20it\x20is\x20not\ + \x20a\x20good\n\x20idea\x20to\x20cap\x20the\x20number\x20of\x20retries\ + \x20a\x20transaction\x20can\x20attempt;\n\x20instead,\x20it\x20is\x20bet\ + ter\x20to\x20limit\x20the\x20total\x20amount\x20of\x20wall\x20time\x20sp\ + ent\n\x20retrying.\n\n\x20###\x20Idle\x20Transactions\n\n\x20A\x20transa\ + ction\x20is\x20considered\x20idle\x20if\x20it\x20has\x20no\x20outstandin\ + g\x20reads\x20or\n\x20SQL\x20queries\x20and\x20has\x20not\x20started\x20\ + a\x20read\x20or\x20SQL\x20query\x20within\x20the\x20last\x2010\n\x20seco\ + nds.\x20Idle\x20transactions\x20can\x20be\x20aborted\x20by\x20Cloud\x20S\ + panner\x20so\x20that\x20they\n\x20don't\x20hold\x20on\x20to\x20locks\x20\ + indefinitely.\x20In\x20that\x20case,\x20the\x20commit\x20will\n\x20fail\ + \x20with\x20error\x20`ABORTED`.\n\n\x20If\x20this\x20behavior\x20is\x20u\ + ndesirable,\x20periodically\x20executing\x20a\x20simple\n\x20SQL\x20quer\ + y\x20in\x20the\x20transaction\x20(e.g.,\x20`SELECT\x201`)\x20prevents\ + \x20the\n\x20transaction\x20from\x20becoming\x20idle.\n\n\x20##\x20Snaps\ + hot\x20Read-Only\x20Transactions\n\n\x20Snapshot\x20read-only\x20transac\ + tions\x20provides\x20a\x20simpler\x20method\x20than\n\x20locking\x20read\ + -write\x20transactions\x20for\x20doing\x20several\x20consistent\n\x20rea\ + ds.\x20However,\x20this\x20type\x20of\x20transaction\x20does\x20not\x20s\ + upport\x20writes.\n\n\x20Snapshot\x20transactions\x20do\x20not\x20take\ + \x20locks.\x20Instead,\x20they\x20work\x20by\n\x20choosing\x20a\x20Cloud\ + \x20Spanner\x20timestamp,\x20then\x20executing\x20all\x20reads\x20at\x20\ + that\n\x20timestamp.\x20Since\x20they\x20do\x20not\x20acquire\x20locks,\ + \x20they\x20do\x20not\x20block\n\x20concurrent\x20read-write\x20transact\ + ions.\n\n\x20Unlike\x20locking\x20read-write\x20transactions,\x20snapsho\ + t\x20read-only\n\x20transactions\x20never\x20abort.\x20They\x20can\x20fa\ + il\x20if\x20the\x20chosen\x20read\n\x20timestamp\x20is\x20garbage\x20col\ + lected;\x20however,\x20the\x20default\x20garbage\n\x20collection\x20poli\ + cy\x20is\x20generous\x20enough\x20that\x20most\x20applications\x20do\x20\ + not\n\x20need\x20to\x20worry\x20about\x20this\x20in\x20practice.\n\n\x20\ + Snapshot\x20read-only\x20transactions\x20do\x20not\x20need\x20to\x20call\ + \n\x20[Commit][google.spanner.v1.Spanner.Commit]\x20or\n\x20[Rollback][g\ + oogle.spanner.v1.Spanner.Rollback]\x20(and\x20in\x20fact\x20are\x20not\n\ + \x20permitted\x20to\x20do\x20so).\n\n\x20To\x20execute\x20a\x20snapshot\ + \x20transaction,\x20the\x20client\x20specifies\x20a\x20timestamp\n\x20bo\ + und,\x20which\x20tells\x20Cloud\x20Spanner\x20how\x20to\x20choose\x20a\ + \x20read\x20timestamp.\n\n\x20The\x20types\x20of\x20timestamp\x20bound\ + \x20are:\n\n\x20\x20\x20-\x20Strong\x20(the\x20default).\n\x20\x20\x20-\ + \x20Bounded\x20staleness.\n\x20\x20\x20-\x20Exact\x20staleness.\n\n\x20I\ + f\x20the\x20Cloud\x20Spanner\x20database\x20to\x20be\x20read\x20is\x20ge\ + ographically\x20distributed,\n\x20stale\x20read-only\x20transactions\x20\ + can\x20execute\x20more\x20quickly\x20than\x20strong\n\x20or\x20read-writ\ + e\x20transaction,\x20because\x20they\x20are\x20able\x20to\x20execute\x20\ + far\n\x20from\x20the\x20leader\x20replica.\n\n\x20Each\x20type\x20of\x20\ + timestamp\x20bound\x20is\x20discussed\x20in\x20detail\x20below.\n\n\x20#\ + ##\x20Strong\n\n\x20Strong\x20reads\x20are\x20guaranteed\x20to\x20see\ + \x20the\x20effects\x20of\x20all\x20transactions\n\x20that\x20have\x20com\ + mitted\x20before\x20the\x20start\x20of\x20the\x20read.\x20Furthermore,\ + \x20all\n\x20rows\x20yielded\x20by\x20a\x20single\x20read\x20are\x20cons\ + istent\x20with\x20each\x20other\x20--\x20if\n\x20any\x20part\x20of\x20th\ + e\x20read\x20observes\x20a\x20transaction,\x20all\x20parts\x20of\x20the\ + \x20read\n\x20see\x20the\x20transaction.\n\n\x20Strong\x20reads\x20are\ + \x20not\x20repeatable:\x20two\x20consecutive\x20strong\x20read-only\n\ + \x20transactions\x20might\x20return\x20inconsistent\x20results\x20if\x20\ + there\x20are\n\x20concurrent\x20writes.\x20If\x20consistency\x20across\ + \x20reads\x20is\x20required,\x20the\n\x20reads\x20should\x20be\x20execut\ + ed\x20within\x20a\x20transaction\x20or\x20at\x20an\x20exact\x20read\n\ + \x20timestamp.\n\n\x20See\x20[TransactionOptions.ReadOnly.strong][google\ + .spanner.v1.TransactionOptions.ReadOnly.strong].\n\n\x20###\x20Exact\x20\ + Staleness\n\n\x20These\x20timestamp\x20bounds\x20execute\x20reads\x20at\ + \x20a\x20user-specified\n\x20timestamp.\x20Reads\x20at\x20a\x20timestamp\ + \x20are\x20guaranteed\x20to\x20see\x20a\x20consistent\n\x20prefix\x20of\ + \x20the\x20global\x20transaction\x20history:\x20they\x20observe\n\x20mod\ + ifications\x20done\x20by\x20all\x20transactions\x20with\x20a\x20commit\ + \x20timestamp\x20<=\n\x20the\x20read\x20timestamp,\x20and\x20observe\x20\ + none\x20of\x20the\x20modifications\x20done\x20by\n\x20transactions\x20wi\ + th\x20a\x20larger\x20commit\x20timestamp.\x20They\x20will\x20block\x20un\ + til\n\x20all\x20conflicting\x20transactions\x20that\x20may\x20be\x20assi\ + gned\x20commit\x20timestamps\n\x20<=\x20the\x20read\x20timestamp\x20have\ + \x20finished.\n\n\x20The\x20timestamp\x20can\x20either\x20be\x20expresse\ + d\x20as\x20an\x20absolute\x20Cloud\x20Spanner\x20commit\n\x20timestamp\ + \x20or\x20a\x20staleness\x20relative\x20to\x20the\x20current\x20time.\n\ + \n\x20These\x20modes\x20do\x20not\x20require\x20a\x20\"negotiation\x20ph\ + ase\"\x20to\x20pick\x20a\n\x20timestamp.\x20As\x20a\x20result,\x20they\ + \x20execute\x20slightly\x20faster\x20than\x20the\n\x20equivalent\x20boun\ + dedly\x20stale\x20concurrency\x20modes.\x20On\x20the\x20other\x20hand,\n\ + \x20boundedly\x20stale\x20reads\x20usually\x20return\x20fresher\x20resul\ + ts.\n\n\x20See\x20[TransactionOptions.ReadOnly.read_timestamp][google.sp\ + anner.v1.TransactionOptions.ReadOnly.read_timestamp]\x20and\n\x20[Transa\ + ctionOptions.ReadOnly.exact_staleness][google.spanner.v1.TransactionOpti\ + ons.ReadOnly.exact_staleness].\n\n\x20###\x20Bounded\x20Staleness\n\n\ + \x20Bounded\x20staleness\x20modes\x20allow\x20Cloud\x20Spanner\x20to\x20\ + pick\x20the\x20read\x20timestamp,\n\x20subject\x20to\x20a\x20user-provid\ + ed\x20staleness\x20bound.\x20Cloud\x20Spanner\x20chooses\x20the\n\x20new\ + est\x20timestamp\x20within\x20the\x20staleness\x20bound\x20that\x20allow\ + s\x20execution\n\x20of\x20the\x20reads\x20at\x20the\x20closest\x20availa\ + ble\x20replica\x20without\x20blocking.\n\n\x20All\x20rows\x20yielded\x20\ + are\x20consistent\x20with\x20each\x20other\x20--\x20if\x20any\x20part\ + \x20of\n\x20the\x20read\x20observes\x20a\x20transaction,\x20all\x20parts\ + \x20of\x20the\x20read\x20see\x20the\n\x20transaction.\x20Boundedly\x20st\ + ale\x20reads\x20are\x20not\x20repeatable:\x20two\x20stale\n\x20reads,\ + \x20even\x20if\x20they\x20use\x20the\x20same\x20staleness\x20bound,\x20c\ + an\x20execute\x20at\n\x20different\x20timestamps\x20and\x20thus\x20retur\ + n\x20inconsistent\x20results.\n\n\x20Boundedly\x20stale\x20reads\x20exec\ + ute\x20in\x20two\x20phases:\x20the\x20first\x20phase\n\x20negotiates\x20\ + a\x20timestamp\x20among\x20all\x20replicas\x20needed\x20to\x20serve\x20t\ + he\n\x20read.\x20In\x20the\x20second\x20phase,\x20reads\x20are\x20execut\ + ed\x20at\x20the\x20negotiated\n\x20timestamp.\n\n\x20As\x20a\x20result\ + \x20of\x20the\x20two\x20phase\x20execution,\x20bounded\x20staleness\x20r\ + eads\x20are\n\x20usually\x20a\x20little\x20slower\x20than\x20comparable\ + \x20exact\x20staleness\n\x20reads.\x20However,\x20they\x20are\x20typical\ + ly\x20able\x20to\x20return\x20fresher\n\x20results,\x20and\x20are\x20mor\ + e\x20likely\x20to\x20execute\x20at\x20the\x20closest\x20replica.\n\n\x20\ + Because\x20the\x20timestamp\x20negotiation\x20requires\x20up-front\x20kn\ + owledge\x20of\n\x20which\x20rows\x20will\x20be\x20read,\x20it\x20can\x20\ + only\x20be\x20used\x20with\x20single-use\n\x20read-only\x20transactions.\ + \n\n\x20See\x20[TransactionOptions.ReadOnly.max_staleness][google.spanne\ + r.v1.TransactionOptions.ReadOnly.max_staleness]\x20and\n\x20[Transaction\ + Options.ReadOnly.min_read_timestamp][google.spanner.v1.TransactionOption\ + s.ReadOnly.min_read_timestamp].\n\n\x20###\x20Old\x20Read\x20Timestamps\ + \x20and\x20Garbage\x20Collection\n\n\x20Cloud\x20Spanner\x20continuously\ + \x20garbage\x20collects\x20deleted\x20and\x20overwritten\x20data\n\x20in\ + \x20the\x20background\x20to\x20reclaim\x20storage\x20space.\x20This\x20p\ + rocess\x20is\x20known\n\x20as\x20\"version\x20GC\".\x20By\x20default,\ + \x20version\x20GC\x20reclaims\x20versions\x20after\x20they\n\x20are\x20o\ + ne\x20hour\x20old.\x20Because\x20of\x20this,\x20Cloud\x20Spanner\x20cann\ + ot\x20perform\x20reads\n\x20at\x20read\x20timestamps\x20more\x20than\x20\ + one\x20hour\x20in\x20the\x20past.\x20This\n\x20restriction\x20also\x20ap\ + plies\x20to\x20in-progress\x20reads\x20and/or\x20SQL\x20queries\x20whose\ + \n\x20timestamp\x20become\x20too\x20old\x20while\x20executing.\x20Reads\ + \x20and\x20SQL\x20queries\x20with\n\x20too-old\x20read\x20timestamps\x20\ + fail\x20with\x20the\x20error\x20`FAILED_PRECONDITION`.\n\n\x20##\x20Part\ + itioned\x20DML\x20Transactions\n\n\x20Partitioned\x20DML\x20transactions\ + \x20are\x20used\x20to\x20execute\x20DML\x20statements\x20with\x20a\n\x20\ + different\x20execution\x20strategy\x20that\x20provides\x20different,\x20\ + and\x20often\x20better,\n\x20scalability\x20properties\x20for\x20large,\ + \x20table-wide\x20operations\x20than\x20DML\x20in\x20a\n\x20ReadWrite\ + \x20transaction.\x20Smaller\x20scoped\x20statements,\x20such\x20as\x20an\ + \x20OLTP\x20workload,\n\x20should\x20prefer\x20using\x20ReadWrite\x20tra\ + nsactions.\n\n\x20Partitioned\x20DML\x20partitions\x20the\x20keyspace\ + \x20and\x20runs\x20the\x20DML\x20statement\x20on\x20each\n\x20partition\ + \x20in\x20separate,\x20internal\x20transactions.\x20These\x20transaction\ + s\x20commit\n\x20automatically\x20when\x20complete,\x20and\x20run\x20ind\ + ependently\x20from\x20one\x20another.\n\n\x20To\x20reduce\x20lock\x20con\ + tention,\x20this\x20execution\x20strategy\x20only\x20acquires\x20read\ + \x20locks\n\x20on\x20rows\x20that\x20match\x20the\x20WHERE\x20clause\x20\ + of\x20the\x20statement.\x20Additionally,\x20the\n\x20smaller\x20per-part\ + ition\x20transactions\x20hold\x20locks\x20for\x20less\x20time.\n\n\x20Th\ + at\x20said,\x20Partitioned\x20DML\x20is\x20not\x20a\x20drop-in\x20replac\ + ement\x20for\x20standard\x20DML\x20used\n\x20in\x20ReadWrite\x20transact\ + ions.\n\n\x20\x20-\x20The\x20DML\x20statement\x20must\x20be\x20fully-par\ + titionable.\x20Specifically,\x20the\x20statement\n\x20\x20\x20\x20must\ + \x20be\x20expressible\x20as\x20the\x20union\x20of\x20many\x20statements\ + \x20which\x20each\x20access\x20only\n\x20\x20\x20\x20a\x20single\x20row\ + \x20of\x20the\x20table.\n\n\x20\x20-\x20The\x20statement\x20is\x20not\ + \x20applied\x20atomically\x20to\x20all\x20rows\x20of\x20the\x20table.\ + \x20Rather,\n\x20\x20\x20\x20the\x20statement\x20is\x20applied\x20atomic\ + ally\x20to\x20partitions\x20of\x20the\x20table,\x20in\n\x20\x20\x20\x20i\ + ndependent\x20transactions.\x20Secondary\x20index\x20rows\x20are\x20upda\ + ted\x20atomically\n\x20\x20\x20\x20with\x20the\x20base\x20table\x20rows.\ + \n\n\x20\x20-\x20Partitioned\x20DML\x20does\x20not\x20guarantee\x20exact\ + ly-once\x20execution\x20semantics\n\x20\x20\x20\x20against\x20a\x20parti\ + tion.\x20The\x20statement\x20will\x20be\x20applied\x20at\x20least\x20onc\ + e\x20to\x20each\n\x20\x20\x20\x20partition.\x20It\x20is\x20strongly\x20r\ + ecommended\x20that\x20the\x20DML\x20statement\x20should\x20be\n\x20\x20\ + \x20\x20idempotent\x20to\x20avoid\x20unexpected\x20results.\x20For\x20in\ + stance,\x20it\x20is\x20potentially\n\x20\x20\x20\x20dangerous\x20to\x20r\ + un\x20a\x20statement\x20such\x20as\n\x20\x20\x20\x20`UPDATE\x20table\x20\ + SET\x20column\x20=\x20column\x20+\x201`\x20as\x20it\x20could\x20be\x20ru\ + n\x20multiple\x20times\n\x20\x20\x20\x20against\x20some\x20rows.\n\n\x20\ + \x20-\x20The\x20partitions\x20are\x20committed\x20automatically\x20-\x20\ + there\x20is\x20no\x20support\x20for\n\x20\x20\x20\x20Commit\x20or\x20Rol\ + lback.\x20If\x20the\x20call\x20returns\x20an\x20error,\x20or\x20if\x20th\ + e\x20client\x20issuing\n\x20\x20\x20\x20the\x20ExecuteSql\x20call\x20die\ + s,\x20it\x20is\x20possible\x20that\x20some\x20rows\x20had\x20the\x20stat\ + ement\n\x20\x20\x20\x20executed\x20on\x20them\x20successfully.\x20It\x20\ + is\x20also\x20possible\x20that\x20statement\x20was\n\x20\x20\x20\x20neve\ + r\x20executed\x20against\x20other\x20rows.\n\n\x20\x20-\x20Partitioned\ + \x20DML\x20transactions\x20may\x20only\x20contain\x20the\x20execution\ + \x20of\x20a\x20single\n\x20\x20\x20\x20DML\x20statement\x20via\x20Execut\ + eSql\x20or\x20ExecuteStreamingSql.\n\n\x20\x20-\x20If\x20any\x20error\ + \x20is\x20encountered\x20during\x20the\x20execution\x20of\x20the\x20part\ + itioned\x20DML\n\x20\x20\x20\x20operation\x20(for\x20instance,\x20a\x20U\ + NIQUE\x20INDEX\x20violation,\x20division\x20by\x20zero,\x20or\x20a\n\x20\ + \x20\x20\x20value\x20that\x20cannot\x20be\x20stored\x20due\x20to\x20sche\ + ma\x20constraints),\x20then\x20the\n\x20\x20\x20\x20operation\x20is\x20s\ + topped\x20at\x20that\x20point\x20and\x20an\x20error\x20is\x20returned.\ + \x20It\x20is\n\x20\x20\x20\x20possible\x20that\x20at\x20this\x20point,\ + \x20some\x20partitions\x20have\x20been\x20committed\x20(or\x20even\n\x20\ + \x20\x20\x20committed\x20multiple\x20times),\x20and\x20other\x20partitio\ + ns\x20have\x20not\x20been\x20run\x20at\x20all.\n\n\x20Given\x20the\x20ab\ + ove,\x20Partitioned\x20DML\x20is\x20good\x20fit\x20for\x20large,\x20data\ + base-wide,\n\x20operations\x20that\x20are\x20idempotent,\x20such\x20as\ + \x20deleting\x20old\x20rows\x20from\x20a\x20very\x20large\n\x20table.\n\ + \n\x0b\n\x03\x04\0\x01\x12\x04\xb3\x02\x08\x1a\nu\n\x04\x04\0\x03\0\x12\ + \x06\xb6\x02\x02\xb8\x02\x03\x1ae\x20Message\x20type\x20to\x20initiate\ + \x20a\x20read-write\x20transaction.\x20Currently\x20this\n\x20transactio\ + n\x20type\x20has\x20no\x20options.\n\n\r\n\x05\x04\0\x03\0\x01\x12\x04\ + \xb6\x02\n\x13\nI\n\x04\x04\0\x03\x01\x12\x06\xbb\x02\x02\xbd\x02\x03\ + \x1a9\x20Message\x20type\x20to\x20initiate\x20a\x20Partitioned\x20DML\ + \x20transaction.\n\n\r\n\x05\x04\0\x03\x01\x01\x12\x04\xbb\x02\n\x18\nC\ + \n\x04\x04\0\x03\x02\x12\x06\xc0\x02\x02\x81\x03\x03\x1a3\x20Message\x20\ + type\x20to\x20initiate\x20a\x20read-only\x20transaction.\n\n\r\n\x05\x04\ + \0\x03\x02\x01\x12\x04\xc0\x02\n\x12\nN\n\x06\x04\0\x03\x02\x08\0\x12\ + \x06\xc2\x02\x04\xfc\x02\x05\x1a<\x20How\x20to\x20choose\x20the\x20times\ + tamp\x20for\x20the\x20read-only\x20transaction.\n\n\x0f\n\x07\x04\0\x03\ + \x02\x08\0\x01\x12\x04\xc2\x02\n\x19\n_\n\x06\x04\0\x03\x02\x02\0\x12\ + \x04\xc5\x02\x06\x16\x1aO\x20Read\x20at\x20a\x20timestamp\x20where\x20al\ + l\x20previously\x20committed\x20transactions\n\x20are\x20visible.\n\n\ + \x0f\n\x07\x04\0\x03\x02\x02\0\x05\x12\x04\xc5\x02\x06\n\n\x0f\n\x07\x04\ + \0\x03\x02\x02\0\x01\x12\x04\xc5\x02\x0b\x11\n\x0f\n\x07\x04\0\x03\x02\ + \x02\0\x03\x12\x04\xc5\x02\x14\x15\n\xc6\x03\n\x06\x04\0\x03\x02\x02\x01\ + \x12\x04\xd1\x02\x067\x1a\xb5\x03\x20Executes\x20all\x20reads\x20at\x20a\ + \x20timestamp\x20>=\x20`min_read_timestamp`.\n\n\x20This\x20is\x20useful\ + \x20for\x20requesting\x20fresher\x20data\x20than\x20some\x20previous\n\ + \x20read,\x20or\x20data\x20that\x20is\x20fresh\x20enough\x20to\x20observ\ + e\x20the\x20effects\x20of\x20some\n\x20previously\x20committed\x20transa\ + ction\x20whose\x20timestamp\x20is\x20known.\n\n\x20Note\x20that\x20this\ + \x20option\x20can\x20only\x20be\x20used\x20in\x20single-use\x20transacti\ + ons.\n\n\x20A\x20timestamp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20fo\ + rmat,\x20accurate\x20to\x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T1\ + 5:01:23.045123456Z\"`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x06\x12\x04\ + \xd1\x02\x06\x1f\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x01\x12\x04\xd1\x02\ + \x202\n\x0f\n\x07\x04\0\x03\x02\x02\x01\x03\x12\x04\xd1\x0256\n\xba\x04\ + \n\x06\x04\0\x03\x02\x02\x02\x12\x04\xe0\x02\x061\x1a\xa9\x04\x20Read\ + \x20data\x20at\x20a\x20timestamp\x20>=\x20`NOW\x20-\x20max_staleness`\n\ + \x20seconds.\x20Guarantees\x20that\x20all\x20writes\x20that\x20have\x20c\ + ommitted\x20more\n\x20than\x20the\x20specified\x20number\x20of\x20second\ + s\x20ago\x20are\x20visible.\x20Because\n\x20Cloud\x20Spanner\x20chooses\ + \x20the\x20exact\x20timestamp,\x20this\x20mode\x20works\x20even\x20if\n\ + \x20the\x20client's\x20local\x20clock\x20is\x20substantially\x20skewed\ + \x20from\x20Cloud\x20Spanner\n\x20commit\x20timestamps.\n\n\x20Useful\ + \x20for\x20reading\x20the\x20freshest\x20data\x20available\x20at\x20a\ + \x20nearby\n\x20replica,\x20while\x20bounding\x20the\x20possible\x20stal\ + eness\x20if\x20the\x20local\n\x20replica\x20has\x20fallen\x20behind.\n\n\ + \x20Note\x20that\x20this\x20option\x20can\x20only\x20be\x20used\x20in\ + \x20single-use\n\x20transactions.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x02\ + \x06\x12\x04\xe0\x02\x06\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x01\x12\ + \x04\xe0\x02\x1f,\n\x0f\n\x07\x04\0\x03\x02\x02\x02\x03\x12\x04\xe0\x02/\ + 0\n\xb6\x04\n\x06\x04\0\x03\x02\x02\x03\x12\x04\xee\x02\x063\x1a\xa5\x04\ + \x20Executes\x20all\x20reads\x20at\x20the\x20given\x20timestamp.\x20Unli\ + ke\x20other\x20modes,\n\x20reads\x20at\x20a\x20specific\x20timestamp\x20\ + are\x20repeatable;\x20the\x20same\x20read\x20at\n\x20the\x20same\x20time\ + stamp\x20always\x20returns\x20the\x20same\x20data.\x20If\x20the\n\x20tim\ + estamp\x20is\x20in\x20the\x20future,\x20the\x20read\x20will\x20block\x20\ + until\x20the\n\x20specified\x20timestamp,\x20modulo\x20the\x20read's\x20\ + deadline.\n\n\x20Useful\x20for\x20large\x20scale\x20consistent\x20reads\ + \x20such\x20as\x20mapreduces,\x20or\n\x20for\x20coordinating\x20many\x20\ + reads\x20against\x20a\x20consistent\x20snapshot\x20of\x20the\n\x20data.\ + \n\n\x20A\x20timestamp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20format\ + ,\x20accurate\x20to\x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T15:01\ + :23.045123456Z\"`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x03\x06\x12\x04\xee\ + \x02\x06\x1f\n\x0f\n\x07\x04\0\x03\x02\x02\x03\x01\x12\x04\xee\x02\x20.\ + \n\x0f\n\x07\x04\0\x03\x02\x02\x03\x03\x12\x04\xee\x0212\n\x92\x04\n\x06\ + \x04\0\x03\x02\x02\x04\x12\x04\xfb\x02\x063\x1a\x81\x04\x20Executes\x20a\ + ll\x20reads\x20at\x20a\x20timestamp\x20that\x20is\x20`exact_staleness`\n\ + \x20old.\x20The\x20timestamp\x20is\x20chosen\x20soon\x20after\x20the\x20\ + read\x20is\x20started.\n\n\x20Guarantees\x20that\x20all\x20writes\x20tha\ + t\x20have\x20committed\x20more\x20than\x20the\n\x20specified\x20number\ + \x20of\x20seconds\x20ago\x20are\x20visible.\x20Because\x20Cloud\x20Spann\ + er\n\x20chooses\x20the\x20exact\x20timestamp,\x20this\x20mode\x20works\ + \x20even\x20if\x20the\x20client's\n\x20local\x20clock\x20is\x20substanti\ + ally\x20skewed\x20from\x20Cloud\x20Spanner\x20commit\n\x20timestamps.\n\ + \n\x20Useful\x20for\x20reading\x20at\x20nearby\x20replicas\x20without\ + \x20the\x20distributed\n\x20timestamp\x20negotiation\x20overhead\x20of\ + \x20`max_staleness`.\n\n\x0f\n\x07\x04\0\x03\x02\x02\x04\x06\x12\x04\xfb\ + \x02\x06\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x04\x01\x12\x04\xfb\x02\x1f.\ + \n\x0f\n\x07\x04\0\x03\x02\x02\x04\x03\x12\x04\xfb\x0212\n\xae\x01\n\x06\ + \x04\0\x03\x02\x02\x05\x12\x04\x80\x03\x04#\x1a\x9d\x01\x20If\x20true,\ + \x20the\x20Cloud\x20Spanner-selected\x20read\x20timestamp\x20is\x20inclu\ + ded\x20in\n\x20the\x20[Transaction][google.spanner.v1.Transaction]\x20me\ + ssage\x20that\x20describes\x20the\x20transaction.\n\n\x11\n\x07\x04\0\ + \x03\x02\x02\x05\x04\x12\x06\x80\x03\x04\xfc\x02\x05\n\x0f\n\x07\x04\0\ + \x03\x02\x02\x05\x05\x12\x04\x80\x03\x04\x08\n\x0f\n\x07\x04\0\x03\x02\ + \x02\x05\x01\x12\x04\x80\x03\t\x1e\n\x0f\n\x07\x04\0\x03\x02\x02\x05\x03\ + \x12\x04\x80\x03!\"\n4\n\x04\x04\0\x08\0\x12\x06\x84\x03\x02\x99\x03\x03\ + \x1a$\x20Required.\x20The\x20type\x20of\x20transaction.\n\n\r\n\x05\x04\ + \0\x08\0\x01\x12\x04\x84\x03\x08\x0c\n\xc2\x01\n\x04\x04\0\x02\0\x12\x04\ + \x8a\x03\x04\x1d\x1a\xb3\x01\x20Transaction\x20may\x20write.\n\n\x20Auth\ + orization\x20to\x20begin\x20a\x20read-write\x20transaction\x20requires\n\ + \x20`spanner.databases.beginOrRollbackReadWriteTransaction`\x20permissio\ + n\n\x20on\x20the\x20`session`\x20resource.\n\n\r\n\x05\x04\0\x02\0\x06\ + \x12\x04\x8a\x03\x04\r\n\r\n\x05\x04\0\x02\0\x01\x12\x04\x8a\x03\x0e\x18\ + \n\r\n\x05\x04\0\x02\0\x03\x12\x04\x8a\x03\x1b\x1c\n\xc8\x01\n\x04\x04\0\ + \x02\x01\x12\x04\x91\x03\x04'\x1a\xb9\x01\x20Partitioned\x20DML\x20trans\ + action.\n\n\x20Authorization\x20to\x20begin\x20a\x20Partitioned\x20DML\ + \x20transaction\x20requires\n\x20`spanner.databases.beginPartitionedDmlT\ + ransaction`\x20permission\n\x20on\x20the\x20`session`\x20resource.\n\n\r\ + \n\x05\x04\0\x02\x01\x06\x12\x04\x91\x03\x04\x12\n\r\n\x05\x04\0\x02\x01\ + \x01\x12\x04\x91\x03\x13\"\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\x91\x03%&\ + \n\xbb\x01\n\x04\x04\0\x02\x02\x12\x04\x98\x03\x04\x1b\x1a\xac\x01\x20Tr\ + ansaction\x20will\x20not\x20write.\n\n\x20Authorization\x20to\x20begin\ + \x20a\x20read-only\x20transaction\x20requires\n\x20`spanner.databases.be\ + ginReadOnlyTransaction`\x20permission\n\x20on\x20the\x20`session`\x20res\ + ource.\n\n\r\n\x05\x04\0\x02\x02\x06\x12\x04\x98\x03\x04\x0c\n\r\n\x05\ + \x04\0\x02\x02\x01\x12\x04\x98\x03\r\x16\n\r\n\x05\x04\0\x02\x02\x03\x12\ + \x04\x98\x03\x19\x1a\n\x1e\n\x02\x04\x01\x12\x06\x9d\x03\0\xaf\x03\x01\ + \x1a\x10\x20A\x20transaction.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\x9d\x03\ + \x08\x13\n\x88\x03\n\x04\x04\x01\x02\0\x12\x04\xa6\x03\x02\x0f\x1a\xf9\ + \x02\x20`id`\x20may\x20be\x20used\x20to\x20identify\x20the\x20transactio\ + n\x20in\x20subsequent\n\x20[Read][google.spanner.v1.Spanner.Read],\n\x20\ + [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql],\n\x20[Commit][google\ + .spanner.v1.Spanner.Commit],\x20or\n\x20[Rollback][google.spanner.v1.Spa\ + nner.Rollback]\x20calls.\n\n\x20Single-use\x20read-only\x20transactions\ + \x20do\x20not\x20have\x20IDs,\x20because\n\x20single-use\x20transactions\ + \x20do\x20not\x20support\x20multiple\x20requests.\n\n\x0f\n\x05\x04\x01\ + \x02\0\x04\x12\x06\xa6\x03\x02\x9d\x03\x15\n\r\n\x05\x04\x01\x02\0\x05\ + \x12\x04\xa6\x03\x02\x07\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xa6\x03\x08\ + \n\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xa6\x03\r\x0e\n\xf2\x02\n\x04\x04\ + \x01\x02\x01\x12\x04\xae\x03\x02/\x1a\xe3\x02\x20For\x20snapshot\x20read\ + -only\x20transactions,\x20the\x20read\x20timestamp\x20chosen\n\x20for\ + \x20the\x20transaction.\x20Not\x20returned\x20by\x20default:\x20see\n\ + \x20[TransactionOptions.ReadOnly.return_read_timestamp][google.spanner.v\ + 1.TransactionOptions.ReadOnly.return_read_timestamp].\n\n\x20A\x20timest\ + amp\x20in\x20RFC3339\x20UTC\x20\\\"Zulu\\\"\x20format,\x20accurate\x20to\ + \x20nanoseconds.\n\x20Example:\x20`\"2014-10-02T15:01:23.045123456Z\"`.\ + \n\n\x0f\n\x05\x04\x01\x02\x01\x04\x12\x06\xae\x03\x02\xa6\x03\x0f\n\r\n\ + \x05\x04\x01\x02\x01\x06\x12\x04\xae\x03\x02\x1b\n\r\n\x05\x04\x01\x02\ + \x01\x01\x12\x04\xae\x03\x1c*\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xae\ + \x03-.\n\x9e\x02\n\x02\x04\x02\x12\x06\xb6\x03\0\xc7\x03\x01\x1a\x8f\x02\ + \x20This\x20message\x20is\x20used\x20to\x20select\x20the\x20transaction\ + \x20in\x20which\x20a\n\x20[Read][google.spanner.v1.Spanner.Read]\x20or\n\ + \x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]\x20call\x20runs.\ + \n\n\x20See\x20[TransactionOptions][google.spanner.v1.TransactionOptions\ + ]\x20for\x20more\x20information\x20about\x20transactions.\n\n\x0b\n\x03\ + \x04\x02\x01\x12\x04\xb6\x03\x08\x1b\ni\n\x04\x04\x02\x08\0\x12\x06\xb9\ + \x03\x02\xc6\x03\x03\x1aY\x20If\x20no\x20fields\x20are\x20set,\x20the\ + \x20default\x20is\x20a\x20single\x20use\x20transaction\n\x20with\x20stro\ + ng\x20concurrency.\n\n\r\n\x05\x04\x02\x08\0\x01\x12\x04\xb9\x03\x08\x10\ + \n\xa9\x01\n\x04\x04\x02\x02\0\x12\x04\xbd\x03\x04&\x1a\x9a\x01\x20Execu\ + te\x20the\x20read\x20or\x20SQL\x20query\x20in\x20a\x20temporary\x20trans\ + action.\n\x20This\x20is\x20the\x20most\x20efficient\x20way\x20to\x20exec\ + ute\x20a\x20transaction\x20that\n\x20consists\x20of\x20a\x20single\x20SQ\ + L\x20query.\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xbd\x03\x04\x16\n\r\n\ + \x05\x04\x02\x02\0\x01\x12\x04\xbd\x03\x17!\n\r\n\x05\x04\x02\x02\0\x03\ + \x12\x04\xbd\x03$%\nR\n\x04\x04\x02\x02\x01\x12\x04\xc0\x03\x04\x11\x1aD\ + \x20Execute\x20the\x20read\x20or\x20SQL\x20query\x20in\x20a\x20previousl\ + y-started\x20transaction.\n\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xc0\ + \x03\x04\t\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xc0\x03\n\x0c\n\r\n\x05\ + \x04\x02\x02\x01\x03\x12\x04\xc0\x03\x0f\x10\n\x98\x02\n\x04\x04\x02\x02\ + \x02\x12\x04\xc5\x03\x04!\x1a\x89\x02\x20Begin\x20a\x20new\x20transactio\ + n\x20and\x20execute\x20this\x20read\x20or\x20SQL\x20query\x20in\n\x20it.\ + \x20The\x20transaction\x20ID\x20of\x20the\x20new\x20transaction\x20is\ + \x20returned\x20in\n\x20[ResultSetMetadata.transaction][google.spanner.v\ + 1.ResultSetMetadata.transaction],\x20which\x20is\x20a\x20[Transaction][g\ + oogle.spanner.v1.Transaction].\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\ + \xc5\x03\x04\x16\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xc5\x03\x17\x1c\n\ + \r\n\x05\x04\x02\x02\x02\x03\x12\x04\xc5\x03\x1f\x20b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/type_pb.rs b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/type_pb.rs new file mode 100644 index 00000000..6a8468fd --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis-raw/src/spanner/v1/type_pb.rs @@ -0,0 +1,936 @@ +// This file is generated by rust-protobuf 2.7.0. Do not edit +// @generated + +// https://github.com/Manishearth/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/spanner/v1/type.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0; + +#[derive(PartialEq,Clone,Default)] +pub struct Type { + // message fields + pub code: TypeCode, + pub array_element_type: ::protobuf::SingularPtrField, + pub struct_type: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Type { + fn default() -> &'a Type { + ::default_instance() + } +} + +impl Type { + pub fn new() -> Type { + ::std::default::Default::default() + } + + // .google.spanner.v1.TypeCode code = 1; + + + pub fn get_code(&self) -> TypeCode { + self.code + } + pub fn clear_code(&mut self) { + self.code = TypeCode::TYPE_CODE_UNSPECIFIED; + } + + // Param is passed by value, moved + pub fn set_code(&mut self, v: TypeCode) { + self.code = v; + } + + // .google.spanner.v1.Type array_element_type = 2; + + + pub fn get_array_element_type(&self) -> &Type { + self.array_element_type.as_ref().unwrap_or_else(|| Type::default_instance()) + } + pub fn clear_array_element_type(&mut self) { + self.array_element_type.clear(); + } + + pub fn has_array_element_type(&self) -> bool { + self.array_element_type.is_some() + } + + // Param is passed by value, moved + pub fn set_array_element_type(&mut self, v: Type) { + self.array_element_type = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_array_element_type(&mut self) -> &mut Type { + if self.array_element_type.is_none() { + self.array_element_type.set_default(); + } + self.array_element_type.as_mut().unwrap() + } + + // Take field + pub fn take_array_element_type(&mut self) -> Type { + self.array_element_type.take().unwrap_or_else(|| Type::new()) + } + + // .google.spanner.v1.StructType struct_type = 3; + + + pub fn get_struct_type(&self) -> &StructType { + self.struct_type.as_ref().unwrap_or_else(|| StructType::default_instance()) + } + pub fn clear_struct_type(&mut self) { + self.struct_type.clear(); + } + + pub fn has_struct_type(&self) -> bool { + self.struct_type.is_some() + } + + // Param is passed by value, moved + pub fn set_struct_type(&mut self, v: StructType) { + self.struct_type = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_struct_type(&mut self) -> &mut StructType { + if self.struct_type.is_none() { + self.struct_type.set_default(); + } + self.struct_type.as_mut().unwrap() + } + + // Take field + pub fn take_struct_type(&mut self) -> StructType { + self.struct_type.take().unwrap_or_else(|| StructType::new()) + } +} + +impl ::protobuf::Message for Type { + fn is_initialized(&self) -> bool { + for v in &self.array_element_type { + if !v.is_initialized() { + return false; + } + }; + for v in &self.struct_type { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.code, 1, &mut self.unknown_fields)? + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.array_element_type)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.struct_type)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.code != TypeCode::TYPE_CODE_UNSPECIFIED { + my_size += ::protobuf::rt::enum_size(1, self.code); + } + if let Some(ref v) = self.array_element_type.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.struct_type.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if self.code != TypeCode::TYPE_CODE_UNSPECIFIED { + os.write_enum(1, self.code.value())?; + } + if let Some(ref v) = self.array_element_type.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.struct_type.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Type { + Type::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( + "code", + |m: &Type| { &m.code }, + |m: &mut Type| { &mut m.code }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "array_element_type", + |m: &Type| { &m.array_element_type }, + |m: &mut Type| { &mut m.array_element_type }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "struct_type", + |m: &Type| { &m.struct_type }, + |m: &mut Type| { &mut m.struct_type }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "Type", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Type { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const Type, + }; + unsafe { + instance.get(Type::new) + } + } +} + +impl ::protobuf::Clear for Type { + fn clear(&mut self) { + self.code = TypeCode::TYPE_CODE_UNSPECIFIED; + self.array_element_type.clear(); + self.struct_type.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Type { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Type { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct StructType { + // message fields + pub fields: ::protobuf::RepeatedField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a StructType { + fn default() -> &'a StructType { + ::default_instance() + } +} + +impl StructType { + pub fn new() -> StructType { + ::std::default::Default::default() + } + + // repeated .google.spanner.v1.StructType.Field fields = 1; + + + pub fn get_fields(&self) -> &[StructType_Field] { + &self.fields + } + pub fn clear_fields(&mut self) { + self.fields.clear(); + } + + // Param is passed by value, moved + pub fn set_fields(&mut self, v: ::protobuf::RepeatedField) { + self.fields = v; + } + + // Mutable pointer to the field. + pub fn mut_fields(&mut self) -> &mut ::protobuf::RepeatedField { + &mut self.fields + } + + // Take field + pub fn take_fields(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.fields, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for StructType { + fn is_initialized(&self) -> bool { + for v in &self.fields { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.fields)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.fields { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + for v in &self.fields { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> StructType { + StructType::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "fields", + |m: &StructType| { &m.fields }, + |m: &mut StructType| { &mut m.fields }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "StructType", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static StructType { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const StructType, + }; + unsafe { + instance.get(StructType::new) + } + } +} + +impl ::protobuf::Clear for StructType { + fn clear(&mut self) { + self.fields.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for StructType { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for StructType { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +pub struct StructType_Field { + // message fields + pub name: ::std::string::String, + pub field_type: ::protobuf::SingularPtrField, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a StructType_Field { + fn default() -> &'a StructType_Field { + ::default_instance() + } +} + +impl StructType_Field { + pub fn new() -> StructType_Field { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.spanner.v1.Type type = 2; + + + pub fn get_field_type(&self) -> &Type { + self.field_type.as_ref().unwrap_or_else(|| Type::default_instance()) + } + pub fn clear_field_type(&mut self) { + self.field_type.clear(); + } + + pub fn has_field_type(&self) -> bool { + self.field_type.is_some() + } + + // Param is passed by value, moved + pub fn set_field_type(&mut self, v: Type) { + self.field_type = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_field_type(&mut self) -> &mut Type { + if self.field_type.is_none() { + self.field_type.set_default(); + } + self.field_type.as_mut().unwrap() + } + + // Take field + pub fn take_field_type(&mut self) -> Type { + self.field_type.take().unwrap_or_else(|| Type::new()) + } +} + +impl ::protobuf::Message for StructType_Field { + fn is_initialized(&self) -> bool { + for v in &self.field_type { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.field_type)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.field_type.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.field_type.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn as_any_mut(&mut self) -> &mut ::std::any::Any { + self as &mut ::std::any::Any + } + fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> StructType_Field { + StructType_Field::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, + }; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &StructType_Field| { &m.name }, + |m: &mut StructType_Field| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( + "type", + |m: &StructType_Field| { &m.field_type }, + |m: &mut StructType_Field| { &mut m.field_type }, + )); + ::protobuf::reflect::MessageDescriptor::new::( + "StructType_Field", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static StructType_Field { + static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const StructType_Field, + }; + unsafe { + instance.get(StructType_Field::new) + } + } +} + +impl ::protobuf::Clear for StructType_Field { + fn clear(&mut self) { + self.name.clear(); + self.field_type.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for StructType_Field { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for StructType_Field { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +pub enum TypeCode { + TYPE_CODE_UNSPECIFIED = 0, + BOOL = 1, + INT64 = 2, + FLOAT64 = 3, + TIMESTAMP = 4, + DATE = 5, + STRING = 6, + BYTES = 7, + ARRAY = 8, + STRUCT = 9, +} + +impl ::protobuf::ProtobufEnum for TypeCode { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(TypeCode::TYPE_CODE_UNSPECIFIED), + 1 => ::std::option::Option::Some(TypeCode::BOOL), + 2 => ::std::option::Option::Some(TypeCode::INT64), + 3 => ::std::option::Option::Some(TypeCode::FLOAT64), + 4 => ::std::option::Option::Some(TypeCode::TIMESTAMP), + 5 => ::std::option::Option::Some(TypeCode::DATE), + 6 => ::std::option::Option::Some(TypeCode::STRING), + 7 => ::std::option::Option::Some(TypeCode::BYTES), + 8 => ::std::option::Option::Some(TypeCode::ARRAY), + 9 => ::std::option::Option::Some(TypeCode::STRUCT), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [TypeCode] = &[ + TypeCode::TYPE_CODE_UNSPECIFIED, + TypeCode::BOOL, + TypeCode::INT64, + TypeCode::FLOAT64, + TypeCode::TIMESTAMP, + TypeCode::DATE, + TypeCode::STRING, + TypeCode::BYTES, + TypeCode::ARRAY, + TypeCode::STRUCT, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, + }; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new("TypeCode", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for TypeCode { +} + +impl ::std::default::Default for TypeCode { + fn default() -> Self { + TypeCode::TYPE_CODE_UNSPECIFIED + } +} + +impl ::protobuf::reflect::ProtobufValue for TypeCode { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1cgoogle/spanner/v1/type.proto\x12\x11google.spanner.v1\x1a\x1cgoogl\ + e/api/annotations.proto\"\xbe\x01\n\x04Type\x12/\n\x04code\x18\x01\x20\ + \x01(\x0e2\x1b.google.spanner.v1.TypeCodeR\x04code\x12E\n\x12array_eleme\ + nt_type\x18\x02\x20\x01(\x0b2\x17.google.spanner.v1.TypeR\x10arrayElemen\ + tType\x12>\n\x0bstruct_type\x18\x03\x20\x01(\x0b2\x1d.google.spanner.v1.\ + StructTypeR\nstructType\"\x93\x01\n\nStructType\x12;\n\x06fields\x18\x01\ + \x20\x03(\x0b2#.google.spanner.v1.StructType.FieldR\x06fields\x1aH\n\x05\ + Field\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12+\n\x04type\x18\ + \x02\x20\x01(\x0b2\x17.google.spanner.v1.TypeR\x04type*\x8e\x01\n\x08Typ\ + eCode\x12\x19\n\x15TYPE_CODE_UNSPECIFIED\x10\0\x12\x08\n\x04BOOL\x10\x01\ + \x12\t\n\x05INT64\x10\x02\x12\x0b\n\x07FLOAT64\x10\x03\x12\r\n\tTIMESTAM\ + P\x10\x04\x12\x08\n\x04DATE\x10\x05\x12\n\n\x06STRING\x10\x06\x12\t\n\ + \x05BYTES\x10\x07\x12\t\n\x05ARRAY\x10\x08\x12\n\n\x06STRUCT\x10\tB\x92\ + \x01\n\x15com.google.spanner.v1B\tTypeProtoP\x01Z8google.golang.org/genp\ + roto/googleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V1\ + \xca\x02\x17Google\\Cloud\\Spanner\\V1J\xc8\"\n\x06\x12\x04\x0e\0u\x01\n\ + \xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202018\x20Go\ + ogle\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Ver\ + sion\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20th\ + is\x20file\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\ + \x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\ + \x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Un\ + less\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\ + \x20writing,\x20software\n\x20distributed\x20under\x20the\x20License\x20\ + is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20\ + WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20expres\ + s\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\ + \x20language\x20governing\x20permissions\x20and\n\x20limitations\x20unde\ + r\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\n\t\n\x02\x03\0\ + \x12\x03\x12\0&\n\x08\n\x01\x08\x12\x03\x14\04\n\t\n\x02\x08%\x12\x03\ + \x14\04\n\x08\n\x01\x08\x12\x03\x15\0O\n\t\n\x02\x08\x0b\x12\x03\x15\0O\ + \n\x08\n\x01\x08\x12\x03\x16\0\"\n\t\n\x02\x08\n\x12\x03\x16\0\"\n\x08\n\ + \x01\x08\x12\x03\x17\0*\n\t\n\x02\x08\x08\x12\x03\x17\0*\n\x08\n\x01\x08\ + \x12\x03\x18\0.\n\t\n\x02\x08\x01\x12\x03\x18\0.\n\x08\n\x01\x08\x12\x03\ + \x19\04\n\t\n\x02\x08)\x12\x03\x19\04\n\x84\x01\n\x02\x04\0\x12\x04\x1e\ + \0)\x01\x1ax\x20`Type`\x20indicates\x20the\x20type\x20of\x20a\x20Cloud\ + \x20Spanner\x20value,\x20as\x20might\x20be\x20stored\x20in\x20a\n\x20tab\ + le\x20cell\x20or\x20returned\x20from\x20an\x20SQL\x20query.\n\n\n\n\x03\ + \x04\0\x01\x12\x03\x1e\x08\x0c\nR\n\x04\x04\0\x02\0\x12\x03\x20\x02\x14\ + \x1aE\x20Required.\x20The\x20[TypeCode][google.spanner.v1.TypeCode]\x20f\ + or\x20this\x20type.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04\x20\x02\x1e\x0e\ + \n\x0c\n\x05\x04\0\x02\0\x06\x12\x03\x20\x02\n\n\x0c\n\x05\x04\0\x02\0\ + \x01\x12\x03\x20\x0b\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x20\x12\x13\ + \n\xa2\x01\n\x04\x04\0\x02\x01\x12\x03$\x02\x1e\x1a\x94\x01\x20If\x20[co\ + de][google.spanner.v1.Type.code]\x20==\x20[ARRAY][google.spanner.v1.Type\ + Code.ARRAY],\x20then\x20`array_element_type`\n\x20is\x20the\x20type\x20o\ + f\x20the\x20array\x20elements.\n\n\r\n\x05\x04\0\x02\x01\x04\x12\x04$\ + \x02\x20\x14\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03$\x02\x06\n\x0c\n\x05\ + \x04\0\x02\x01\x01\x12\x03$\x07\x19\n\x0c\n\x05\x04\0\x02\x01\x03\x12\ + \x03$\x1c\x1d\n\xad\x01\n\x04\x04\0\x02\x02\x12\x03(\x02\x1d\x1a\x9f\x01\ + \x20If\x20[code][google.spanner.v1.Type.code]\x20==\x20[STRUCT][google.s\ + panner.v1.TypeCode.STRUCT],\x20then\x20`struct_type`\n\x20provides\x20ty\ + pe\x20information\x20for\x20the\x20struct's\x20fields.\n\n\r\n\x05\x04\0\ + \x02\x02\x04\x12\x04(\x02$\x1e\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03(\ + \x02\x0c\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03(\r\x18\n\x0c\n\x05\x04\0\ + \x02\x02\x03\x12\x03(\x1b\x1c\nd\n\x02\x04\x01\x12\x04,\0C\x01\x1aX\x20`\ + StructType`\x20defines\x20the\x20fields\x20of\x20a\x20[STRUCT][google.sp\ + anner.v1.TypeCode.STRUCT]\x20type.\n\n\n\n\x03\x04\x01\x01\x12\x03,\x08\ + \x12\n@\n\x04\x04\x01\x03\0\x12\x04.\x02:\x03\x1a2\x20Message\x20represe\ + nting\x20a\x20single\x20field\x20of\x20a\x20struct.\n\n\x0c\n\x05\x04\ + \x01\x03\0\x01\x12\x03.\n\x0f\n\x99\x03\n\x06\x04\x01\x03\0\x02\0\x12\ + \x036\x04\x14\x1a\x89\x03\x20The\x20name\x20of\x20the\x20field.\x20For\ + \x20reads,\x20this\x20is\x20the\x20column\x20name.\x20For\n\x20SQL\x20qu\ + eries,\x20it\x20is\x20the\x20column\x20alias\x20(e.g.,\x20`\"Word\"`\x20\ + in\x20the\n\x20query\x20`\"SELECT\x20'hello'\x20AS\x20Word\"`),\x20or\ + \x20the\x20column\x20name\x20(e.g.,\n\x20`\"ColName\"`\x20in\x20the\x20q\ + uery\x20`\"SELECT\x20ColName\x20FROM\x20Table\"`).\x20Some\n\x20columns\ + \x20might\x20have\x20an\x20empty\x20name\x20(e.g.,\x20!\"SELECT\n\x20UPP\ + ER(ColName)\"`).\x20Note\x20that\x20a\x20query\x20result\x20can\x20conta\ + in\n\x20multiple\x20fields\x20with\x20the\x20same\x20name.\n\n\x0f\n\x07\ + \x04\x01\x03\0\x02\0\x04\x12\x046\x04.\x11\n\x0e\n\x07\x04\x01\x03\0\x02\ + \0\x05\x12\x036\x04\n\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\x12\x036\x0b\ + \x0f\n\x0e\n\x07\x04\x01\x03\0\x02\0\x03\x12\x036\x12\x13\n'\n\x06\x04\ + \x01\x03\0\x02\x01\x12\x039\x04\x12\x1a\x18\x20The\x20type\x20of\x20the\ + \x20field.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x04\x12\x049\x046\x14\n\ + \x0e\n\x07\x04\x01\x03\0\x02\x01\x06\x12\x039\x04\x08\n\x0e\n\x07\x04\ + \x01\x03\0\x02\x01\x01\x12\x039\t\r\n\x0e\n\x07\x04\x01\x03\0\x02\x01\ + \x03\x12\x039\x10\x11\n\x8a\x03\n\x04\x04\x01\x02\0\x12\x03B\x02\x1c\x1a\ + \xfc\x02\x20The\x20list\x20of\x20fields\x20that\x20make\x20up\x20this\ + \x20struct.\x20Order\x20is\n\x20significant,\x20because\x20values\x20of\ + \x20this\x20struct\x20type\x20are\x20represented\x20as\n\x20lists,\x20wh\ + ere\x20the\x20order\x20of\x20field\x20values\x20matches\x20the\x20order\ + \x20of\n\x20fields\x20in\x20the\x20[StructType][google.spanner.v1.Struct\ + Type].\x20In\x20turn,\x20the\x20order\x20of\x20fields\n\x20matches\x20th\ + e\x20order\x20of\x20columns\x20in\x20a\x20read\x20request,\x20or\x20the\ + \x20order\x20of\n\x20fields\x20in\x20the\x20`SELECT`\x20clause\x20of\x20\ + a\x20query.\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03B\x02\n\n\x0c\n\x05\ + \x04\x01\x02\0\x06\x12\x03B\x0b\x10\n\x0c\n\x05\x04\x01\x02\0\x01\x12\ + \x03B\x11\x17\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03B\x1a\x1b\n\xd9\x02\n\ + \x02\x05\0\x12\x04L\0u\x01\x1a\xcc\x02\x20`TypeCode`\x20is\x20used\x20as\ + \x20part\x20of\x20[Type][google.spanner.v1.Type]\x20to\n\x20indicate\x20\ + the\x20type\x20of\x20a\x20Cloud\x20Spanner\x20value.\n\n\x20Each\x20lega\ + l\x20value\x20of\x20a\x20type\x20can\x20be\x20encoded\x20to\x20or\x20dec\ + oded\x20from\x20a\x20JSON\n\x20value,\x20using\x20the\x20encodings\x20de\ + scribed\x20below.\x20All\x20Cloud\x20Spanner\x20values\x20can\n\x20be\ + \x20`null`,\x20regardless\x20of\x20type;\x20`null`s\x20are\x20always\x20\ + encoded\x20as\x20a\x20JSON\n\x20`null`.\n\n\n\n\x03\x05\0\x01\x12\x03L\ + \x05\r\n\x1d\n\x04\x05\0\x02\0\x12\x03N\x02\x1c\x1a\x10\x20Not\x20specif\ + ied.\n\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03N\x02\x17\n\x0c\n\x05\x05\0\ + \x02\0\x02\x12\x03N\x1a\x1b\n1\n\x04\x05\0\x02\x01\x12\x03Q\x02\x0b\x1a$\ + \x20Encoded\x20as\x20JSON\x20`true`\x20or\x20`false`.\n\n\x0c\n\x05\x05\ + \0\x02\x01\x01\x12\x03Q\x02\x06\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03Q\t\ + \n\n6\n\x04\x05\0\x02\x02\x12\x03T\x02\x0c\x1a)\x20Encoded\x20as\x20`str\ + ing`,\x20in\x20decimal\x20format.\n\n\x0c\n\x05\x05\0\x02\x02\x01\x12\ + \x03T\x02\x07\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03T\n\x0b\n\\\n\x04\x05\ + \0\x02\x03\x12\x03X\x02\x0e\x1aO\x20Encoded\x20as\x20`number`,\x20or\x20\ + the\x20strings\x20`\"NaN\"`,\x20`\"Infinity\"`,\x20or\n\x20`\"-Infinity\ + \"`.\n\n\x0c\n\x05\x05\0\x02\x03\x01\x12\x03X\x02\t\n\x0c\n\x05\x05\0\ + \x02\x03\x02\x12\x03X\x0c\r\n\xdd\x02\n\x04\x05\0\x02\x04\x12\x03b\x02\ + \x10\x1a\xcf\x02\x20Encoded\x20as\x20`string`\x20in\x20RFC\x203339\x20ti\ + mestamp\x20format.\x20The\x20time\x20zone\n\x20must\x20be\x20present,\ + \x20and\x20must\x20be\x20`\"Z\"`.\n\n\x20If\x20the\x20schema\x20has\x20t\ + he\x20column\x20option\n\x20`allow_commit_timestamp=true`,\x20the\x20pla\ + ceholder\x20string\n\x20`\"spanner.commit_timestamp()\"`\x20can\x20be\ + \x20used\x20to\x20instruct\x20the\x20system\n\x20to\x20insert\x20the\x20\ + commit\x20timestamp\x20associated\x20with\x20the\x20transaction\n\x20com\ + mit.\n\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03b\x02\x0b\n\x0c\n\x05\x05\0\ + \x02\x04\x02\x12\x03b\x0e\x0f\n;\n\x04\x05\0\x02\x05\x12\x03e\x02\x0b\ + \x1a.\x20Encoded\x20as\x20`string`\x20in\x20RFC\x203339\x20date\x20forma\ + t.\n\n\x0c\n\x05\x05\0\x02\x05\x01\x12\x03e\x02\x06\n\x0c\n\x05\x05\0\ + \x02\x05\x02\x12\x03e\t\n\n#\n\x04\x05\0\x02\x06\x12\x03h\x02\r\x1a\x16\ + \x20Encoded\x20as\x20`string`.\n\n\x0c\n\x05\x05\0\x02\x06\x01\x12\x03h\ + \x02\x08\n\x0c\n\x05\x05\0\x02\x06\x02\x12\x03h\x0b\x0c\nZ\n\x04\x05\0\ + \x02\x07\x12\x03l\x02\x0c\x1aM\x20Encoded\x20as\x20a\x20base64-encoded\ + \x20`string`,\x20as\x20described\x20in\x20RFC\x204648,\n\x20section\x204\ + .\n\n\x0c\n\x05\x05\0\x02\x07\x01\x12\x03l\x02\x07\n\x0c\n\x05\x05\0\x02\ + \x07\x02\x12\x03l\n\x0b\n\x99\x01\n\x04\x05\0\x02\x08\x12\x03p\x02\x0c\ + \x1a\x8b\x01\x20Encoded\x20as\x20`list`,\x20where\x20the\x20list\x20elem\ + ents\x20are\x20represented\n\x20according\x20to\x20[array_element_type][\ + google.spanner.v1.Type.array_element_type].\n\n\x0c\n\x05\x05\0\x02\x08\ + \x01\x12\x03p\x02\x07\n\x0c\n\x05\x05\0\x02\x08\x02\x12\x03p\n\x0b\n\x94\ + \x01\n\x04\x05\0\x02\t\x12\x03t\x02\r\x1a\x86\x01\x20Encoded\x20as\x20`l\ + ist`,\x20where\x20list\x20element\x20`i`\x20is\x20represented\x20accordi\ + ng\n\x20to\x20[struct_type.fields[i]][google.spanner.v1.StructType.field\ + s].\n\n\x0c\n\x05\x05\0\x02\t\x01\x12\x03t\x02\x08\n\x0c\n\x05\x05\0\x02\ + \t\x02\x12\x03t\x0b\x0cb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { + lock: ::protobuf::lazy::ONCE_INIT, + ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, +}; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/vendor/mozilla-rust-sdk/googleapis/Cargo.toml b/vendor/mozilla-rust-sdk/googleapis/Cargo.toml new file mode 100644 index 00000000..d1720c6b --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "googleapis" +version = "0.0.1" +authors = ["Ferrous Systems"] +edition = "2018" + +[dependencies] +futures = "0.1.28" +grpcio = "0.5.0-alpha.1" + +[dependencies.googleapis-raw] +version = "0.0.1" +path = "../googleapis-raw" diff --git a/vendor/mozilla-rust-sdk/googleapis/README.md b/vendor/mozilla-rust-sdk/googleapis/README.md new file mode 100644 index 00000000..d45a3d57 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis/README.md @@ -0,0 +1,5 @@ +# googleapis + +These are high-level bindings for Google APIs. + +Work in progress. Use [`googleapis-raw`](../googleapis-raw) for now. diff --git a/vendor/mozilla-rust-sdk/googleapis/examples/spanner-client.rs b/vendor/mozilla-rust-sdk/googleapis/examples/spanner-client.rs new file mode 100644 index 00000000..5df6b781 --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis/examples/spanner-client.rs @@ -0,0 +1,13 @@ +use std::error::Error; + +use googleapis::spanner; + +fn main() -> Result<(), Box> { + // An example database inside Mozilla's Spanner instance. + let database = "projects/mozilla-rust-sdk-dev/instances/mozilla-spanner-dev/databases/mydb"; + + // Create a Spanner client. + let client = spanner::Client::new(database)?; + + Ok(()) +} diff --git a/vendor/mozilla-rust-sdk/googleapis/src/lib.rs b/vendor/mozilla-rust-sdk/googleapis/src/lib.rs new file mode 100644 index 00000000..ed7f97ee --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis/src/lib.rs @@ -0,0 +1,23 @@ +use std::error; +use std::fmt; + +pub mod spanner; + +#[derive(Debug)] +pub struct Error(grpcio::Error); + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&self.0, f) + } +} + +impl error::Error for Error {} + +impl From for Error { + fn from(err: grpcio::Error) -> Error { + Error(err) + } +} + +pub type Result = std::result::Result; diff --git a/vendor/mozilla-rust-sdk/googleapis/src/spanner.rs b/vendor/mozilla-rust-sdk/googleapis/src/spanner.rs new file mode 100644 index 00000000..1a5ff31f --- /dev/null +++ b/vendor/mozilla-rust-sdk/googleapis/src/spanner.rs @@ -0,0 +1,57 @@ +//! Spanner client. + +use std::sync::Arc; + +use googleapis_raw::spanner::v1::{ + spanner::{CreateSessionRequest, Session}, + spanner_grpc::SpannerClient, +}; +use grpcio::{CallOption, ChannelBuilder, ChannelCredentials, EnvBuilder, MetadataBuilder}; + +pub struct Client { + database: String, + client: SpannerClient, + session: Session, +} + +impl Client { + /// Creates a new Spanner client. + /// + /// # Examples + /// + /// ```no_run + /// use googleapis::spanner; + /// + /// let db = "projects/my_project/instances/my_instance/databases/my_database"; + /// let client = spanner::Client::new(db); + /// ``` + pub fn new(database: &str) -> crate::Result { + let database = database.to_string(); + let endpoint = "spanner.googleapis.com:443"; + + // Set up the gRPC environment. + let env = Arc::new(EnvBuilder::new().build()); + let creds = ChannelCredentials::google_default_credentials()?; + + // Create a Spanner client. + let chan = ChannelBuilder::new(env.clone()) + .max_send_message_len(100 << 20) + .max_receive_message_len(100 << 20) + .secure_connect(&endpoint, creds); + let client = SpannerClient::new(chan); + + let mut req = CreateSessionRequest::new(); + req.set_database(database.to_string()); + let mut meta = MetadataBuilder::new(); + meta.add_str("google-cloud-resource-prefix", &database)?; + meta.add_str("x-goog-api-client", "googleapis-rs")?; + let opt = CallOption::default().headers(meta.build()); + let session = client.create_session_opt(&req, opt)?; + + Ok(Client { + database, + client, + session, + }) + } +}