diff --git a/.github/workflows/bigtable-conformance.yml b/.github/workflows/bigtable-conformance.yml new file mode 100644 index 000000000000..2f29d263d1f9 --- /dev/null +++ b/.github/workflows/bigtable-conformance.yml @@ -0,0 +1,44 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# Github action job to test core java library features on +# downstream client libraries before they are released. +on: + push: + branches: + - main + pull_request: + paths: + - '**[Bb]ig[Tt]able**' +name: bigtable-conformance +jobs: + conformance: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + submodules: true + - uses: actions/checkout@v4 + with: + repository: googleapis/cloud-bigtable-clients-test + ref: main + path: cloud-bigtable-clients-test + - uses: actions/setup-dotnet@v4 + with: + dotnet-version: 6.0.x + - uses: actions/setup-go@v5 + with: + go-version: '>=1.20.2' + - run: dotnet --version + - run: go version + - run: bash apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/bigtable-conformance.sh \ No newline at end of file diff --git a/Directory.Packages.props b/Directory.Packages.props index 83bd2441802a..0ee49ff21cd2 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -46,5 +46,7 @@ + + diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Google.Cloud.Bigtable.V2.ConformanceTests.csproj b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Google.Cloud.Bigtable.V2.ConformanceTests.csproj new file mode 100644 index 000000000000..7708611d3169 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Google.Cloud.Bigtable.V2.ConformanceTests.csproj @@ -0,0 +1,17 @@ + + + + net6.0 + enable + + + + + + + + + + + + diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Program.cs b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Program.cs new file mode 100644 index 000000000000..ef77608fa1eb --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Program.cs @@ -0,0 +1,32 @@ +// Copyright 2025 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using google.bigtable.testproxy; + +var builder = WebApplication.CreateBuilder(args); + +builder.WebHost.ConfigureKestrel(options => {}); +// Additional configuration is required to successfully run gRPC on macOS. +// For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682 + +// Add services to the container. +builder.Services.AddGrpc(); + +var app = builder.Build(); + +// Configure the HTTP request pipeline. +app.MapGrpcService(); +app.MapGet("/", () => "gRPC service for running conformance tests for Google.Cloud.Bigtable.V2"); + +app.Run(); diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Protos/test_proxy.proto b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Protos/test_proxy.proto new file mode 100644 index 000000000000..2e82b62843b4 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Protos/test_proxy.proto @@ -0,0 +1,352 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package google.bigtable.testproxy; + +import "google/api/client.proto"; +import "google/bigtable/v2/bigtable.proto"; +import "google/bigtable/v2/data.proto"; +import "google/protobuf/duration.proto"; +import "google/rpc/status.proto"; + +option go_package = "./testproxypb"; +option csharp_namespace = "Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy"; + +// A config flag that dictates how the optional features should be enabled +// during the client creation. The optional features customize how the client +// interacts with the server, and are defined in +// https://github.com/googleapis/googleapis/blob/master/google/bigtable/v2/feature_flags.proto +enum OptionalFeatureConfig { + OPTIONAL_FEATURE_CONFIG_DEFAULT = 0; + + OPTIONAL_FEATURE_CONFIG_ENABLE_ALL = 1; +} + +// Request to test proxy service to create a client object. +message CreateClientRequest { + message SecurityOptions { + // Access token to use for client credentials. If empty, the client will not + // use any call credentials. Certain implementations may require `use_ssl` + // to be set when using this. + string access_token = 1; + + // Whether to use SSL channel credentials when connecting to the data + // endpoint. + bool use_ssl = 2; + + // If using SSL channel credentials, override the SSL endpoint to match the + // host that is specified in the backend's certificate. Also sets the + // client's authority header value. + string ssl_endpoint_override = 3; + + // PEM encoding of the server root certificates. If not set, the default + // root certs will be used instead. The default can be overridden via the + // GRPC_DEFAULT_SSL_ROOTS_FILE_PATH env var. + string ssl_root_certs_pem = 4; + } + + // A unique ID associated with the client object to be created. + string client_id = 1; + + // The "host:port" address of the data API endpoint (i.e. the backend being + // proxied to). Example: 127.0.0.1:38543. If you want to connect to a local + // emulator via BIGTABLE_EMULATOR_HOST environment variable, you can use + // "emulator" instead of "host:port" for this field. + string data_target = 2; + + // The project for all calls on this client. + string project_id = 3; + + // The instance for all calls on this client. + string instance_id = 4; + + // Optional app profile for all calls on this client. + // Some client bindings allow specifying the app profile on a per-operation + // basis. We don't yet support this in the proxy API, but may in the future. + string app_profile_id = 5; + + // If provided, a custom timeout will be set for each API call conducted by + // the created client. Otherwise, the default timeout from the client library + // will be used. Note that the override applies to all the methods. + google.protobuf.Duration per_operation_timeout = 6; + + // Optional config that dictates how the optional features should be enabled + // during the client creation. Please check the enum type's docstring above. + OptionalFeatureConfig optional_feature_config = 7; + + // Options to allow connecting to backends with channel and/or call + // credentials. This is needed internally by Cloud Bigtable's own testing + // frameworks.It is not necessary to support these fields for client + // conformance testing. + // + // WARNING: this allows the proxy to connect to a real production + // CBT backend with the right options, however, the proxy itself is insecure + // so it is not recommended to use it with real credentials or outside testing + // contexts. + SecurityOptions security_options = 8; +} + +// Response from test proxy service for CreateClientRequest. +message CreateClientResponse {} + +// Request to test proxy service to close a client object. +message CloseClientRequest { + // The ID of the target client object. + string client_id = 1; +} + +// Response from test proxy service for CloseClientRequest. +message CloseClientResponse {} + +// Request to test proxy service to remove a client object. +message RemoveClientRequest { + // The ID of the target client object. + string client_id = 1; +} + +// Response from test proxy service for RemoveClientRequest. +message RemoveClientResponse {} + +// Request to test proxy service to read a row. +message ReadRowRequest { + // The ID of the target client object. + string client_id = 1; + + // The unique name of the table from which to read the row. + // Values are of the form + // `projects//instances//tables/`. + string table_name = 4; + + // The row key of the target row. + string row_key = 2; + + // The row filter to be applied to the target row. + google.bigtable.v2.RowFilter filter = 3; +} + +// Response from test proxy service for ReadRowRequest or +// ReadModifyWriteRowRequest. +message RowResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; + + // The contents of a single row. + google.bigtable.v2.Row row = 2; +} + +// Request to test proxy service to read rows. +message ReadRowsRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.ReadRowsRequest request = 2; + + // The streaming read can be canceled before all items are seen. + // Has no effect if non-positive. + int32 cancel_after_rows = 3; +} + +// Response from test proxy service for ReadRowsRequest. +message RowsResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; + + // The contents of rows. + repeated google.bigtable.v2.Row rows = 2; +} + +// Request to test proxy service to mutate a row. +message MutateRowRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.MutateRowRequest request = 2; +} + +// Response from test proxy service for MutateRowRequest. +message MutateRowResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; +} + +// Request to test proxy service to mutate rows. +message MutateRowsRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.MutateRowsRequest request = 2; +} + +// Response from test proxy service for MutateRowsRequest. +message MutateRowsResult { + // The RPC status from the client binding, corresponding to the + // whole operation. + google.rpc.Status status = 1; + + // The results corresponding to the failed rows. + repeated google.bigtable.v2.MutateRowsResponse.Entry entries = 2; +} + +// Request to test proxy service to check and mutate a row. +message CheckAndMutateRowRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.CheckAndMutateRowRequest request = 2; +} + +// Response from test proxy service for CheckAndMutateRowRequest. +message CheckAndMutateRowResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; + + // The raw response from the Bigtable server. + google.bigtable.v2.CheckAndMutateRowResponse result = 2; +} + +// Request to test proxy service to sample row keys. +message SampleRowKeysRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.SampleRowKeysRequest request = 2; +} + +// Response from test proxy service for SampleRowKeysRequest. +message SampleRowKeysResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; + + // The raw responses from the Bigtable server. + repeated google.bigtable.v2.SampleRowKeysResponse samples = 2; +} + +// Request to test proxy service to read modify write a row. +message ReadModifyWriteRowRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.ReadModifyWriteRowRequest request = 2; +} + +// Request to test proxy service to execute a query. +message ExecuteQueryRequest { + // The ID of the target client object. + string client_id = 1; + + // The raw request to the Bigtable server. + google.bigtable.v2.ExecuteQueryRequest request = 2; +} + +// Response from test proxy service for ExecuteQueryRequest. +message ExecuteQueryResult { + // The RPC status from the client binding. + google.rpc.Status status = 1; + + // deprecated + google.bigtable.v2.ResultSetMetadata result_set_metadata = 2; + + // Name and type information for the query result. + ResultSetMetadata metadata = 4; + + // Encoded version of the ResultSet. Should not contain type information. + repeated SqlRow rows = 3; +} + +// Schema information for the query result. +message ResultSetMetadata { + // Column metadata for each column inthe query result. + repeated google.bigtable.v2.ColumnMetadata columns = 1; +} + +// Representation of a single row in the query result. +message SqlRow { + // Columnar values returned by the query. + repeated google.bigtable.v2.Value values = 1; +} + +// Note that all RPCs are unary, even when the equivalent client binding call +// may be streaming. This is an intentional simplification. +// +// Most methods have sync (default) and async variants. For async variants, +// the proxy is expected to perform the async operation, then wait for results +// before delivering them back to the driver client. +// +// Operations that may have interesting concurrency characteristics are +// represented explicitly in the API (see ReadRowsRequest.cancel_after_rows). +// We include such operations only when they can be meaningfully performed +// through client bindings. +// +// Users should generally avoid setting deadlines for requests to the Proxy +// because operations are not cancelable. If the deadline is set anyway, please +// understand that the underlying operation will continue to be executed even +// after the deadline expires. +service CloudBigtableV2TestProxy { + option (google.api.default_host) = + "bigtable-test-proxy-not-accessible.googleapis.com"; + + // Client management: + // + // Creates a client in the proxy. + // Each client has its own dedicated channel(s), and can be used concurrently + // and independently with other clients. + rpc CreateClient(CreateClientRequest) returns (CreateClientResponse) {} + + // Closes a client in the proxy, making it not accept new requests. + rpc CloseClient(CloseClientRequest) returns (CloseClientResponse) {} + + // Removes a client in the proxy, making it inaccessible. Client closing + // should be done by CloseClient() separately. + rpc RemoveClient(RemoveClientRequest) returns (RemoveClientResponse) {} + + // Bigtable operations: for each operation, you should use the synchronous or + // asynchronous variant of the client method based on the `use_async_method` + // setting of the client instance. For starters, you can choose to implement + // one variant, and return UNIMPLEMENTED status for the other. + // + // Reads a row with the client instance. + // The result row may not be present in the response. + // Callers should check for it (e.g. calling has_row() in C++). + rpc ReadRow(ReadRowRequest) returns (RowResult) {} + + // Reads rows with the client instance. + rpc ReadRows(ReadRowsRequest) returns (RowsResult) {} + + // Writes a row with the client instance. + rpc MutateRow(MutateRowRequest) returns (MutateRowResult) {} + + // Writes multiple rows with the client instance. + rpc BulkMutateRows(MutateRowsRequest) returns (MutateRowsResult) {} + + // Performs a check-and-mutate-row operation with the client instance. + rpc CheckAndMutateRow(CheckAndMutateRowRequest) + returns (CheckAndMutateRowResult) {} + + // Obtains a row key sampling with the client instance. + rpc SampleRowKeys(SampleRowKeysRequest) returns (SampleRowKeysResult) {} + + // Performs a read-modify-write operation with the client. + rpc ReadModifyWriteRow(ReadModifyWriteRowRequest) returns (RowResult) {} + + // Executes a BTQL query with the client. + rpc ExecuteQuery(ExecuteQueryRequest) returns (ExecuteQueryResult) {} +} diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Services/CloudBigtableV2TestProxyImpl.cs b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Services/CloudBigtableV2TestProxyImpl.cs new file mode 100644 index 000000000000..1ba9d25d0c58 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/Services/CloudBigtableV2TestProxyImpl.cs @@ -0,0 +1,331 @@ +// Copyright 2025 Google Inc. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +using Google.Api.Gax; +using Google.Api.Gax.Grpc; +using Google.Apis.Auth.OAuth2; +using Google.Cloud.Bigtable.Common.V2; +using Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy; +using Google.Cloud.Bigtable.V2; +using Grpc.Auth; +using Grpc.Core; + +namespace google.bigtable.testproxy; + +public sealed class CloudBigtableV2TestProxyImpl : CloudBigtableV2TestProxy.CloudBigtableV2TestProxyBase +{ + private static readonly Dictionary s_clientMap = new Dictionary(); + + public override async Task CreateClient(CreateClientRequest request, ServerCallContext context) + { + try + { + BigtableServiceApiSettings settings = BigtableServiceApiSettings.GetDefault(); + settings.AppProfileId = request.AppProfileId; + + MaybeOverrideTimeoutSetting(settings); + + BigtableClientBuilder builder = new BigtableClientBuilder + { + Settings = settings + }; + + if (request.SecurityOptions is null) + { + Environment.SetEnvironmentVariable("BIGTABLE_EMULATOR_HOST", request.DataTarget); + builder.EmulatorDetection = EmulatorDetection.EmulatorOnly; + } + else + { + builder.Endpoint = request.DataTarget; + builder.ChannelCredentials = GetChannelCredentials(); + builder.GrpcChannelOptions = GetChannelOptions(); + } + + s_clientMap[request.ClientId] = await builder.BuildAsync(); + } + catch (Exception e) + { + throw new RpcException(new Status(StatusCode.Internal, e.Message, e)); + } + + return new CreateClientResponse(); + + void MaybeOverrideTimeoutSetting(BigtableServiceApiSettings settings) + { + if (request.PerOperationTimeout is not null) + { + CallSettings callSettings = CallSettings.FromExpiration(Expiration.FromTimeout(request.PerOperationTimeout.ToTimeSpan())); + settings.CheckAndMutateRowSettings = callSettings; + settings.ExecuteQuerySettings = callSettings; + settings.MutateRowSettings = callSettings; + settings.MutateRowsSettings = callSettings; + settings.ReadRowsSettings = callSettings; + settings.ReadModifyWriteRowSettings = callSettings; + settings.SampleRowKeysSettings = callSettings; + settings.CallSettings = callSettings; + } + } + + ChannelCredentials GetChannelCredentials() + { + if (request.SecurityOptions.AccessToken is null) + { + return request.SecurityOptions.UseSsl ? new SslCredentials(request.SecurityOptions.SslRootCertsPem) : ChannelCredentials.Insecure; + } + GoogleCredential googleCredential = GoogleCredential.FromAccessToken(request.SecurityOptions.AccessToken); + return request.SecurityOptions.UseSsl + ? ChannelCredentials.Create(new SslCredentials(request.SecurityOptions.SslRootCertsPem), googleCredential.ToCallCredentials()) + : googleCredential.ToChannelCredentials(); + } + + GrpcChannelOptions GetChannelOptions() => request.SecurityOptions.SslEndpointOverride is not null + ? GrpcChannelOptions.Empty.WithCustomOption("grpc.ssl_target_name_override", request.SecurityOptions.SslEndpointOverride) + : null; + } + + public override Task CloseClient(CloseClientRequest request, ServerCallContext context) + { + return Task.FromResult(new CloseClientResponse()); + } + + public override Task RemoveClient(RemoveClientRequest request, ServerCallContext context) + { + string clientId = request.ClientId; + bool removed = s_clientMap.Remove(clientId); + if (!removed) + { + throw new RpcException(new Status(StatusCode.NotFound, $"Client {clientId} not found.")); + } + return Task.FromResult(new RemoveClientResponse()); + } + + public override async Task ReadRow(ReadRowRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + TableName tableName = TableName.Parse(request.TableName); + try + { + Row row = await bigtableClient.ReadRowAsync(tableName, + new BigtableByteString(request.RowKey), + request.Filter); + string message = row is null ? $"ReadRow didn't find row: {request.RowKey}" : "ReadRow succeeded"; + return new RowResult + { + Row = row, + Status = SetSuccessStatus(message) + }; + } + catch (RpcException e) + { + return new RowResult + { + Status = SetExceptionStatus(e) + }; + } + } + public override async Task ReadRows(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + RowsResult rowsResult = new RowsResult(); + try + { + ReadRowsStream stream = bigtableClient.ReadRows(request.Request); + await foreach (Row row in stream) + { + rowsResult.Rows.Add(row); + } + string message = rowsResult.Rows.Count == 0 ? $"ReadRows didn't find rows or deadline exceeded" : "ReadRows succeeded"; + rowsResult.Status = SetSuccessStatus(message); + return rowsResult; + } + catch (RpcException e) + { + rowsResult.Status = SetExceptionStatus(e); + return rowsResult; + } + catch (InvalidOperationException e) + { + if (e.Message.Contains("NewRow key must be greater than the previous row's")) + { + rowsResult.Status = new Google.Rpc.Status() + { + Message = "increasing decreasing" + }; + } + return rowsResult; + } + } + + public override async Task MutateRow(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + try + { + MutateRowResponse response = await bigtableClient.MutateRowAsync(request.Request); + string message = "MutateRow succeeded"; + return new MutateRowResult + { + Status = SetSuccessStatus(message) + }; + } + catch (RpcException e) + { + return new MutateRowResult + { + Status = SetExceptionStatus(e) + }; + } + } + + public override async Task BulkMutateRows(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + MutateRowsResult result = new MutateRowsResult(); + try + { + MutateRowsResponse response = await bigtableClient.MutateRowsAsync(request.Request); + string message = "MutateRows succeeded"; + result.Status = SetSuccessStatus(message); + foreach (MutateRowsResponse.Types.Entry entry in response.Entries) + { + if (entry.Status.Code > 0) + { + result.Entries.Add(entry); + } + } + return result; + } + catch (RpcException e) + { + result.Status = SetExceptionStatus(e); + if (e.StatusCode == StatusCode.DeadlineExceeded) + { + int i = 0; + foreach (Google.Cloud.Bigtable.V2.MutateRowsRequest.Types.Entry entry in request.Request.Entries) + { + MutateRowsResponse.Types.Entry failedResponseEntry = new MutateRowsResponse.Types.Entry(); + failedResponseEntry.Index = i; + failedResponseEntry.Status = new Google.Rpc.Status() + { + Code = (int) Google.Rpc.Code.DeadlineExceeded + }; + result.Entries.Add(failedResponseEntry); + i++; + } + } + return result; + } + } + + public override async Task CheckAndMutateRow(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + try + { + CheckAndMutateRowResponse response = await bigtableClient.CheckAndMutateRowAsync(request.Request); + string message = "CheckAndMutateRow succeeded"; + return new CheckAndMutateRowResult + { + Result = response, + Status = SetSuccessStatus(message) + }; + } + catch (RpcException e) + { + return new CheckAndMutateRowResult + { + Status = SetExceptionStatus(e) + }; + } + } + + public override async Task SampleRowKeys(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + try + { + BigtableServiceApiClient.SampleRowKeysStream stream = bigtableClient.SampleRowKeys(request.Request); + SampleRowKeysResult result = new SampleRowKeysResult(); + result.Samples.Add(await stream.ToListAsync()); + string message = result.Samples.Count == 0 ? "SampleRowKeys did not find sample" : "SampleRowKeys succeeded"; + result.Status = SetSuccessStatus(message); + return result; + } + catch (RpcException e) + { + return new SampleRowKeysResult + { + Status = SetExceptionStatus(e) + }; + } + } + + public override async Task ReadModifyWriteRow(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, ServerCallContext context) + { + BigtableClient bigtableClient = GetClient(request.ClientId, context); + try + { + Row row = (await bigtableClient.ReadModifyWriteRowAsync(request.Request)).Row; + string message = row is null ? "ReadModifyRow didn't find row" : "ReadModifyRow succeeded"; + return new RowResult + { + Row = row, + Status = SetSuccessStatus(message) + }; + } + catch (RpcException e) + { + return new RowResult + { + Status = SetExceptionStatus(e) + }; + } + } + + public override Task ExecuteQuery(Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, ServerCallContext context) + { + throw new NotImplementedException(); + } + + public static CloudBigtableV2TestProxyImpl Create() => new(); + + private BigtableClient GetClient(string clientId, ServerCallContext context) + { + if (!s_clientMap.ContainsKey(clientId)) + { + throw new RpcException(new Status(StatusCode.NotFound, $"Client {clientId} not found.")); + } + + return s_clientMap[clientId]; + } + + private static Google.Rpc.Status SetExceptionStatus(RpcException e) + { + return new Google.Rpc.Status() + { + Code = (int) e.Status.StatusCode, + Message = e.Message + }; + } + + private static Google.Rpc.Status SetSuccessStatus(string message) + { + return new Google.Rpc.Status() + { + Code = (int) Google.Rpc.Code.Ok, + Message = message + }; + } +} diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxy.g.cs b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxy.g.cs new file mode 100644 index 000000000000..e8d93b920251 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxy.g.cs @@ -0,0 +1,6069 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: test_proxy.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy { + + /// Holder for reflection information generated from test_proxy.proto + public static partial class TestProxyReflection { + + #region Descriptor + /// File descriptor for test_proxy.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static TestProxyReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChB0ZXN0X3Byb3h5LnByb3RvEhlnb29nbGUuYmlndGFibGUudGVzdHByb3h5", + "Ghdnb29nbGUvYXBpL2NsaWVudC5wcm90bxohZ29vZ2xlL2JpZ3RhYmxlL3Yy", + "L2JpZ3RhYmxlLnByb3RvGh1nb29nbGUvYmlndGFibGUvdjIvZGF0YS5wcm90", + "bxoeZ29vZ2xlL3Byb3RvYnVmL2R1cmF0aW9uLnByb3RvGhdnb29nbGUvcnBj", + "L3N0YXR1cy5wcm90byLaAwoTQ3JlYXRlQ2xpZW50UmVxdWVzdBIRCgljbGll", + "bnRfaWQYASABKAkSEwoLZGF0YV90YXJnZXQYAiABKAkSEgoKcHJvamVjdF9p", + "ZBgDIAEoCRITCgtpbnN0YW5jZV9pZBgEIAEoCRIWCg5hcHBfcHJvZmlsZV9p", + "ZBgFIAEoCRI4ChVwZXJfb3BlcmF0aW9uX3RpbWVvdXQYBiABKAsyGS5nb29n", + "bGUucHJvdG9idWYuRHVyYXRpb24SUQoXb3B0aW9uYWxfZmVhdHVyZV9jb25m", + "aWcYByABKA4yMC5nb29nbGUuYmlndGFibGUudGVzdHByb3h5Lk9wdGlvbmFs", + "RmVhdHVyZUNvbmZpZxJYChBzZWN1cml0eV9vcHRpb25zGAggASgLMj4uZ29v", + "Z2xlLmJpZ3RhYmxlLnRlc3Rwcm94eS5DcmVhdGVDbGllbnRSZXF1ZXN0LlNl", + "Y3VyaXR5T3B0aW9ucxpzCg9TZWN1cml0eU9wdGlvbnMSFAoMYWNjZXNzX3Rv", + "a2VuGAEgASgJEg8KB3VzZV9zc2wYAiABKAgSHQoVc3NsX2VuZHBvaW50X292", + "ZXJyaWRlGAMgASgJEhoKEnNzbF9yb290X2NlcnRzX3BlbRgEIAEoCSIWChRD", + "cmVhdGVDbGllbnRSZXNwb25zZSInChJDbG9zZUNsaWVudFJlcXVlc3QSEQoJ", + "Y2xpZW50X2lkGAEgASgJIhUKE0Nsb3NlQ2xpZW50UmVzcG9uc2UiKAoTUmVt", + "b3ZlQ2xpZW50UmVxdWVzdBIRCgljbGllbnRfaWQYASABKAkiFgoUUmVtb3Zl", + "Q2xpZW50UmVzcG9uc2UidwoOUmVhZFJvd1JlcXVlc3QSEQoJY2xpZW50X2lk", + "GAEgASgJEhIKCnRhYmxlX25hbWUYBCABKAkSDwoHcm93X2tleRgCIAEoCRIt", + "CgZmaWx0ZXIYAyABKAsyHS5nb29nbGUuYmlndGFibGUudjIuUm93RmlsdGVy", + "IlUKCVJvd1Jlc3VsdBIiCgZzdGF0dXMYASABKAsyEi5nb29nbGUucnBjLlN0", + "YXR1cxIkCgNyb3cYAiABKAsyFy5nb29nbGUuYmlndGFibGUudjIuUm93InUK", + "D1JlYWRSb3dzUmVxdWVzdBIRCgljbGllbnRfaWQYASABKAkSNAoHcmVxdWVz", + "dBgCIAEoCzIjLmdvb2dsZS5iaWd0YWJsZS52Mi5SZWFkUm93c1JlcXVlc3QS", + "GQoRY2FuY2VsX2FmdGVyX3Jvd3MYAyABKAUiVwoKUm93c1Jlc3VsdBIiCgZz", + "dGF0dXMYASABKAsyEi5nb29nbGUucnBjLlN0YXR1cxIlCgRyb3dzGAIgAygL", + "MhcuZ29vZ2xlLmJpZ3RhYmxlLnYyLlJvdyJcChBNdXRhdGVSb3dSZXF1ZXN0", + "EhEKCWNsaWVudF9pZBgBIAEoCRI1CgdyZXF1ZXN0GAIgASgLMiQuZ29vZ2xl", + "LmJpZ3RhYmxlLnYyLk11dGF0ZVJvd1JlcXVlc3QiNQoPTXV0YXRlUm93UmVz", + "dWx0EiIKBnN0YXR1cxgBIAEoCzISLmdvb2dsZS5ycGMuU3RhdHVzIl4KEU11", + "dGF0ZVJvd3NSZXF1ZXN0EhEKCWNsaWVudF9pZBgBIAEoCRI2CgdyZXF1ZXN0", + "GAIgASgLMiUuZ29vZ2xlLmJpZ3RhYmxlLnYyLk11dGF0ZVJvd3NSZXF1ZXN0", + "InUKEE11dGF0ZVJvd3NSZXN1bHQSIgoGc3RhdHVzGAEgASgLMhIuZ29vZ2xl", + "LnJwYy5TdGF0dXMSPQoHZW50cmllcxgCIAMoCzIsLmdvb2dsZS5iaWd0YWJs", + "ZS52Mi5NdXRhdGVSb3dzUmVzcG9uc2UuRW50cnkibAoYQ2hlY2tBbmRNdXRh", + "dGVSb3dSZXF1ZXN0EhEKCWNsaWVudF9pZBgBIAEoCRI9CgdyZXF1ZXN0GAIg", + "ASgLMiwuZ29vZ2xlLmJpZ3RhYmxlLnYyLkNoZWNrQW5kTXV0YXRlUm93UmVx", + "dWVzdCJ8ChdDaGVja0FuZE11dGF0ZVJvd1Jlc3VsdBIiCgZzdGF0dXMYASAB", + "KAsyEi5nb29nbGUucnBjLlN0YXR1cxI9CgZyZXN1bHQYAiABKAsyLS5nb29n", + "bGUuYmlndGFibGUudjIuQ2hlY2tBbmRNdXRhdGVSb3dSZXNwb25zZSJkChRT", + "YW1wbGVSb3dLZXlzUmVxdWVzdBIRCgljbGllbnRfaWQYASABKAkSOQoHcmVx", + "dWVzdBgCIAEoCzIoLmdvb2dsZS5iaWd0YWJsZS52Mi5TYW1wbGVSb3dLZXlz", + "UmVxdWVzdCJ1ChNTYW1wbGVSb3dLZXlzUmVzdWx0EiIKBnN0YXR1cxgBIAEo", + "CzISLmdvb2dsZS5ycGMuU3RhdHVzEjoKB3NhbXBsZXMYAiADKAsyKS5nb29n", + "bGUuYmlndGFibGUudjIuU2FtcGxlUm93S2V5c1Jlc3BvbnNlIm4KGVJlYWRN", + "b2RpZnlXcml0ZVJvd1JlcXVlc3QSEQoJY2xpZW50X2lkGAEgASgJEj4KB3Jl", + "cXVlc3QYAiABKAsyLS5nb29nbGUuYmlndGFibGUudjIuUmVhZE1vZGlmeVdy", + "aXRlUm93UmVxdWVzdCJiChNFeGVjdXRlUXVlcnlSZXF1ZXN0EhEKCWNsaWVu", + "dF9pZBgBIAEoCRI4CgdyZXF1ZXN0GAIgASgLMicuZ29vZ2xlLmJpZ3RhYmxl", + "LnYyLkV4ZWN1dGVRdWVyeVJlcXVlc3Qi7QEKEkV4ZWN1dGVRdWVyeVJlc3Vs", + "dBIiCgZzdGF0dXMYASABKAsyEi5nb29nbGUucnBjLlN0YXR1cxJCChNyZXN1", + "bHRfc2V0X21ldGFkYXRhGAIgASgLMiUuZ29vZ2xlLmJpZ3RhYmxlLnYyLlJl", + "c3VsdFNldE1ldGFkYXRhEj4KCG1ldGFkYXRhGAQgASgLMiwuZ29vZ2xlLmJp", + "Z3RhYmxlLnRlc3Rwcm94eS5SZXN1bHRTZXRNZXRhZGF0YRIvCgRyb3dzGAMg", + "AygLMiEuZ29vZ2xlLmJpZ3RhYmxlLnRlc3Rwcm94eS5TcWxSb3ciSAoRUmVz", + "dWx0U2V0TWV0YWRhdGESMwoHY29sdW1ucxgBIAMoCzIiLmdvb2dsZS5iaWd0", + "YWJsZS52Mi5Db2x1bW5NZXRhZGF0YSIzCgZTcWxSb3cSKQoGdmFsdWVzGAEg", + "AygLMhkuZ29vZ2xlLmJpZ3RhYmxlLnYyLlZhbHVlKmQKFU9wdGlvbmFsRmVh", + "dHVyZUNvbmZpZxIjCh9PUFRJT05BTF9GRUFUVVJFX0NPTkZJR19ERUZBVUxU", + "EAASJgoiT1BUSU9OQUxfRkVBVFVSRV9DT05GSUdfRU5BQkxFX0FMTBABMpUK", + "ChhDbG91ZEJpZ3RhYmxlVjJUZXN0UHJveHkScQoMQ3JlYXRlQ2xpZW50Ei4u", + "Z29vZ2xlLmJpZ3RhYmxlLnRlc3Rwcm94eS5DcmVhdGVDbGllbnRSZXF1ZXN0", + "Gi8uZ29vZ2xlLmJpZ3RhYmxlLnRlc3Rwcm94eS5DcmVhdGVDbGllbnRSZXNw", + "b25zZSIAEm4KC0Nsb3NlQ2xpZW50Ei0uZ29vZ2xlLmJpZ3RhYmxlLnRlc3Rw", + "cm94eS5DbG9zZUNsaWVudFJlcXVlc3QaLi5nb29nbGUuYmlndGFibGUudGVz", + "dHByb3h5LkNsb3NlQ2xpZW50UmVzcG9uc2UiABJxCgxSZW1vdmVDbGllbnQS", + "Li5nb29nbGUuYmlndGFibGUudGVzdHByb3h5LlJlbW92ZUNsaWVudFJlcXVl", + "c3QaLy5nb29nbGUuYmlndGFibGUudGVzdHByb3h5LlJlbW92ZUNsaWVudFJl", + "c3BvbnNlIgASXAoHUmVhZFJvdxIpLmdvb2dsZS5iaWd0YWJsZS50ZXN0cHJv", + "eHkuUmVhZFJvd1JlcXVlc3QaJC5nb29nbGUuYmlndGFibGUudGVzdHByb3h5", + "LlJvd1Jlc3VsdCIAEl8KCFJlYWRSb3dzEiouZ29vZ2xlLmJpZ3RhYmxlLnRl", + "c3Rwcm94eS5SZWFkUm93c1JlcXVlc3QaJS5nb29nbGUuYmlndGFibGUudGVz", + "dHByb3h5LlJvd3NSZXN1bHQiABJmCglNdXRhdGVSb3cSKy5nb29nbGUuYmln", + "dGFibGUudGVzdHByb3h5Lk11dGF0ZVJvd1JlcXVlc3QaKi5nb29nbGUuYmln", + "dGFibGUudGVzdHByb3h5Lk11dGF0ZVJvd1Jlc3VsdCIAEm0KDkJ1bGtNdXRh", + "dGVSb3dzEiwuZ29vZ2xlLmJpZ3RhYmxlLnRlc3Rwcm94eS5NdXRhdGVSb3dz", + "UmVxdWVzdBorLmdvb2dsZS5iaWd0YWJsZS50ZXN0cHJveHkuTXV0YXRlUm93", + "c1Jlc3VsdCIAEn4KEUNoZWNrQW5kTXV0YXRlUm93EjMuZ29vZ2xlLmJpZ3Rh", + "YmxlLnRlc3Rwcm94eS5DaGVja0FuZE11dGF0ZVJvd1JlcXVlc3QaMi5nb29n", + "bGUuYmlndGFibGUudGVzdHByb3h5LkNoZWNrQW5kTXV0YXRlUm93UmVzdWx0", + "IgAScgoNU2FtcGxlUm93S2V5cxIvLmdvb2dsZS5iaWd0YWJsZS50ZXN0cHJv", + "eHkuU2FtcGxlUm93S2V5c1JlcXVlc3QaLi5nb29nbGUuYmlndGFibGUudGVz", + "dHByb3h5LlNhbXBsZVJvd0tleXNSZXN1bHQiABJyChJSZWFkTW9kaWZ5V3Jp", + "dGVSb3cSNC5nb29nbGUuYmlndGFibGUudGVzdHByb3h5LlJlYWRNb2RpZnlX", + "cml0ZVJvd1JlcXVlc3QaJC5nb29nbGUuYmlndGFibGUudGVzdHByb3h5LlJv", + "d1Jlc3VsdCIAEm8KDEV4ZWN1dGVRdWVyeRIuLmdvb2dsZS5iaWd0YWJsZS50", + "ZXN0cHJveHkuRXhlY3V0ZVF1ZXJ5UmVxdWVzdBotLmdvb2dsZS5iaWd0YWJs", + "ZS50ZXN0cHJveHkuRXhlY3V0ZVF1ZXJ5UmVzdWx0IgAaNMpBMWJpZ3RhYmxl", + "LXRlc3QtcHJveHktbm90LWFjY2Vzc2libGUuZ29vZ2xlYXBpcy5jb21CRVoN", + "Li90ZXN0cHJveHlwYqoCM0dvb2dsZS5DbG91ZC5CaWd0YWJsZS5WMi5Db25m", + "b3JtYW5jZVRlc3RzLlRlc3RQcm94eWIGcHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Api.ClientReflection.Descriptor, global::Google.Cloud.Bigtable.V2.BigtableReflection.Descriptor, global::Google.Cloud.Bigtable.V2.DataReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Rpc.StatusReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Parser, new[]{ "ClientId", "DataTarget", "ProjectId", "InstanceId", "AppProfileId", "PerOperationTimeout", "OptionalFeatureConfig", "SecurityOptions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions.Parser, new[]{ "AccessToken", "UseSsl", "SslEndpointOverride", "SslRootCertsPem" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientResponse), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest.Parser, new[]{ "ClientId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientResponse), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest.Parser, new[]{ "ClientId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientResponse), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest.Parser, new[]{ "ClientId", "TableName", "RowKey", "Filter" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult.Parser, new[]{ "Status", "Row" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest.Parser, new[]{ "ClientId", "Request", "CancelAfterRows" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowsResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowsResult.Parser, new[]{ "Status", "Rows" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowResult.Parser, new[]{ "Status" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsResult.Parser, new[]{ "Status", "Entries" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowResult.Parser, new[]{ "Status", "Result" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysResult.Parser, new[]{ "Status", "Samples" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest.Parser, new[]{ "ClientId", "Request" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryResult), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryResult.Parser, new[]{ "Status", "ResultSetMetadata", "Metadata", "Rows" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata.Parser, new[]{ "Columns" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SqlRow), global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SqlRow.Parser, new[]{ "Values" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + /// + /// A config flag that dictates how the optional features should be enabled + /// during the client creation. The optional features customize how the client + /// interacts with the server, and are defined in + /// https://github.com/googleapis/googleapis/blob/master/google/bigtable/v2/feature_flags.proto + /// + public enum OptionalFeatureConfig { + [pbr::OriginalName("OPTIONAL_FEATURE_CONFIG_DEFAULT")] Default = 0, + [pbr::OriginalName("OPTIONAL_FEATURE_CONFIG_ENABLE_ALL")] EnableAll = 1, + } + + #endregion + + #region Messages + /// + /// Request to test proxy service to create a client object. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CreateClientRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateClientRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientRequest(CreateClientRequest other) : this() { + clientId_ = other.clientId_; + dataTarget_ = other.dataTarget_; + projectId_ = other.projectId_; + instanceId_ = other.instanceId_; + appProfileId_ = other.appProfileId_; + perOperationTimeout_ = other.perOperationTimeout_ != null ? other.perOperationTimeout_.Clone() : null; + optionalFeatureConfig_ = other.optionalFeatureConfig_; + securityOptions_ = other.securityOptions_ != null ? other.securityOptions_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientRequest Clone() { + return new CreateClientRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// A unique ID associated with the client object to be created. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "data_target" field. + public const int DataTargetFieldNumber = 2; + private string dataTarget_ = ""; + /// + /// The "host:port" address of the data API endpoint (i.e. the backend being + /// proxied to). Example: 127.0.0.1:38543. If you want to connect to a local + /// emulator via BIGTABLE_EMULATOR_HOST environment variable, you can use + /// "emulator" instead of "host:port" for this field. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DataTarget { + get { return dataTarget_; } + set { + dataTarget_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "project_id" field. + public const int ProjectIdFieldNumber = 3; + private string projectId_ = ""; + /// + /// The project for all calls on this client. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ProjectId { + get { return projectId_; } + set { + projectId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_id" field. + public const int InstanceIdFieldNumber = 4; + private string instanceId_ = ""; + /// + /// The instance for all calls on this client. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceId { + get { return instanceId_; } + set { + instanceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "app_profile_id" field. + public const int AppProfileIdFieldNumber = 5; + private string appProfileId_ = ""; + /// + /// Optional app profile for all calls on this client. + /// Some client bindings allow specifying the app profile on a per-operation + /// basis. We don't yet support this in the proxy API, but may in the future. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AppProfileId { + get { return appProfileId_; } + set { + appProfileId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "per_operation_timeout" field. + public const int PerOperationTimeoutFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Duration perOperationTimeout_; + /// + /// If provided, a custom timeout will be set for each API call conducted by + /// the created client. Otherwise, the default timeout from the client library + /// will be used. Note that the override applies to all the methods. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Duration PerOperationTimeout { + get { return perOperationTimeout_; } + set { + perOperationTimeout_ = value; + } + } + + /// Field number for the "optional_feature_config" field. + public const int OptionalFeatureConfigFieldNumber = 7; + private global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig optionalFeatureConfig_ = global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default; + /// + /// Optional config that dictates how the optional features should be enabled + /// during the client creation. Please check the enum type's docstring above. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig OptionalFeatureConfig { + get { return optionalFeatureConfig_; } + set { + optionalFeatureConfig_ = value; + } + } + + /// Field number for the "security_options" field. + public const int SecurityOptionsFieldNumber = 8; + private global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions securityOptions_; + /// + /// Options to allow connecting to backends with channel and/or call + /// credentials. This is needed internally by Cloud Bigtable's own testing + /// frameworks.It is not necessary to support these fields for client + /// conformance testing. + /// + /// WARNING: this allows the proxy to connect to a real production + /// CBT backend with the right options, however, the proxy itself is insecure + /// so it is not recommended to use it with real credentials or outside testing + /// contexts. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions SecurityOptions { + get { return securityOptions_; } + set { + securityOptions_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CreateClientRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CreateClientRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (DataTarget != other.DataTarget) return false; + if (ProjectId != other.ProjectId) return false; + if (InstanceId != other.InstanceId) return false; + if (AppProfileId != other.AppProfileId) return false; + if (!object.Equals(PerOperationTimeout, other.PerOperationTimeout)) return false; + if (OptionalFeatureConfig != other.OptionalFeatureConfig) return false; + if (!object.Equals(SecurityOptions, other.SecurityOptions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (DataTarget.Length != 0) hash ^= DataTarget.GetHashCode(); + if (ProjectId.Length != 0) hash ^= ProjectId.GetHashCode(); + if (InstanceId.Length != 0) hash ^= InstanceId.GetHashCode(); + if (AppProfileId.Length != 0) hash ^= AppProfileId.GetHashCode(); + if (perOperationTimeout_ != null) hash ^= PerOperationTimeout.GetHashCode(); + if (OptionalFeatureConfig != global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default) hash ^= OptionalFeatureConfig.GetHashCode(); + if (securityOptions_ != null) hash ^= SecurityOptions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (DataTarget.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DataTarget); + } + if (ProjectId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ProjectId); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(InstanceId); + } + if (AppProfileId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(AppProfileId); + } + if (perOperationTimeout_ != null) { + output.WriteRawTag(50); + output.WriteMessage(PerOperationTimeout); + } + if (OptionalFeatureConfig != global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default) { + output.WriteRawTag(56); + output.WriteEnum((int) OptionalFeatureConfig); + } + if (securityOptions_ != null) { + output.WriteRawTag(66); + output.WriteMessage(SecurityOptions); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (DataTarget.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DataTarget); + } + if (ProjectId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ProjectId); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(InstanceId); + } + if (AppProfileId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(AppProfileId); + } + if (perOperationTimeout_ != null) { + output.WriteRawTag(50); + output.WriteMessage(PerOperationTimeout); + } + if (OptionalFeatureConfig != global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default) { + output.WriteRawTag(56); + output.WriteEnum((int) OptionalFeatureConfig); + } + if (securityOptions_ != null) { + output.WriteRawTag(66); + output.WriteMessage(SecurityOptions); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (DataTarget.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DataTarget); + } + if (ProjectId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProjectId); + } + if (InstanceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceId); + } + if (AppProfileId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AppProfileId); + } + if (perOperationTimeout_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PerOperationTimeout); + } + if (OptionalFeatureConfig != global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptionalFeatureConfig); + } + if (securityOptions_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityOptions); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CreateClientRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.DataTarget.Length != 0) { + DataTarget = other.DataTarget; + } + if (other.ProjectId.Length != 0) { + ProjectId = other.ProjectId; + } + if (other.InstanceId.Length != 0) { + InstanceId = other.InstanceId; + } + if (other.AppProfileId.Length != 0) { + AppProfileId = other.AppProfileId; + } + if (other.perOperationTimeout_ != null) { + if (perOperationTimeout_ == null) { + PerOperationTimeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + PerOperationTimeout.MergeFrom(other.PerOperationTimeout); + } + if (other.OptionalFeatureConfig != global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig.Default) { + OptionalFeatureConfig = other.OptionalFeatureConfig; + } + if (other.securityOptions_ != null) { + if (securityOptions_ == null) { + SecurityOptions = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions(); + } + SecurityOptions.MergeFrom(other.SecurityOptions); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + DataTarget = input.ReadString(); + break; + } + case 26: { + ProjectId = input.ReadString(); + break; + } + case 34: { + InstanceId = input.ReadString(); + break; + } + case 42: { + AppProfileId = input.ReadString(); + break; + } + case 50: { + if (perOperationTimeout_ == null) { + PerOperationTimeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(PerOperationTimeout); + break; + } + case 56: { + OptionalFeatureConfig = (global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig) input.ReadEnum(); + break; + } + case 66: { + if (securityOptions_ == null) { + SecurityOptions = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions(); + } + input.ReadMessage(SecurityOptions); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + DataTarget = input.ReadString(); + break; + } + case 26: { + ProjectId = input.ReadString(); + break; + } + case 34: { + InstanceId = input.ReadString(); + break; + } + case 42: { + AppProfileId = input.ReadString(); + break; + } + case 50: { + if (perOperationTimeout_ == null) { + PerOperationTimeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(PerOperationTimeout); + break; + } + case 56: { + OptionalFeatureConfig = (global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.OptionalFeatureConfig) input.ReadEnum(); + break; + } + case 66: { + if (securityOptions_ == null) { + SecurityOptions = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Types.SecurityOptions(); + } + input.ReadMessage(SecurityOptions); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the CreateClientRequest message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SecurityOptions : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SecurityOptions()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SecurityOptions() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SecurityOptions(SecurityOptions other) : this() { + accessToken_ = other.accessToken_; + useSsl_ = other.useSsl_; + sslEndpointOverride_ = other.sslEndpointOverride_; + sslRootCertsPem_ = other.sslRootCertsPem_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SecurityOptions Clone() { + return new SecurityOptions(this); + } + + /// Field number for the "access_token" field. + public const int AccessTokenFieldNumber = 1; + private string accessToken_ = ""; + /// + /// Access token to use for client credentials. If empty, the client will not + /// use any call credentials. Certain implementations may require `use_ssl` + /// to be set when using this. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AccessToken { + get { return accessToken_; } + set { + accessToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "use_ssl" field. + public const int UseSslFieldNumber = 2; + private bool useSsl_; + /// + /// Whether to use SSL channel credentials when connecting to the data + /// endpoint. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool UseSsl { + get { return useSsl_; } + set { + useSsl_ = value; + } + } + + /// Field number for the "ssl_endpoint_override" field. + public const int SslEndpointOverrideFieldNumber = 3; + private string sslEndpointOverride_ = ""; + /// + /// If using SSL channel credentials, override the SSL endpoint to match the + /// host that is specified in the backend's certificate. Also sets the + /// client's authority header value. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SslEndpointOverride { + get { return sslEndpointOverride_; } + set { + sslEndpointOverride_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "ssl_root_certs_pem" field. + public const int SslRootCertsPemFieldNumber = 4; + private string sslRootCertsPem_ = ""; + /// + /// PEM encoding of the server root certificates. If not set, the default + /// root certs will be used instead. The default can be overridden via the + /// GRPC_DEFAULT_SSL_ROOTS_FILE_PATH env var. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SslRootCertsPem { + get { return sslRootCertsPem_; } + set { + sslRootCertsPem_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SecurityOptions); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SecurityOptions other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AccessToken != other.AccessToken) return false; + if (UseSsl != other.UseSsl) return false; + if (SslEndpointOverride != other.SslEndpointOverride) return false; + if (SslRootCertsPem != other.SslRootCertsPem) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (AccessToken.Length != 0) hash ^= AccessToken.GetHashCode(); + if (UseSsl != false) hash ^= UseSsl.GetHashCode(); + if (SslEndpointOverride.Length != 0) hash ^= SslEndpointOverride.GetHashCode(); + if (SslRootCertsPem.Length != 0) hash ^= SslRootCertsPem.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (AccessToken.Length != 0) { + output.WriteRawTag(10); + output.WriteString(AccessToken); + } + if (UseSsl != false) { + output.WriteRawTag(16); + output.WriteBool(UseSsl); + } + if (SslEndpointOverride.Length != 0) { + output.WriteRawTag(26); + output.WriteString(SslEndpointOverride); + } + if (SslRootCertsPem.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SslRootCertsPem); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (AccessToken.Length != 0) { + output.WriteRawTag(10); + output.WriteString(AccessToken); + } + if (UseSsl != false) { + output.WriteRawTag(16); + output.WriteBool(UseSsl); + } + if (SslEndpointOverride.Length != 0) { + output.WriteRawTag(26); + output.WriteString(SslEndpointOverride); + } + if (SslRootCertsPem.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SslRootCertsPem); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (AccessToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AccessToken); + } + if (UseSsl != false) { + size += 1 + 1; + } + if (SslEndpointOverride.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SslEndpointOverride); + } + if (SslRootCertsPem.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SslRootCertsPem); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SecurityOptions other) { + if (other == null) { + return; + } + if (other.AccessToken.Length != 0) { + AccessToken = other.AccessToken; + } + if (other.UseSsl != false) { + UseSsl = other.UseSsl; + } + if (other.SslEndpointOverride.Length != 0) { + SslEndpointOverride = other.SslEndpointOverride; + } + if (other.SslRootCertsPem.Length != 0) { + SslRootCertsPem = other.SslRootCertsPem; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + AccessToken = input.ReadString(); + break; + } + case 16: { + UseSsl = input.ReadBool(); + break; + } + case 26: { + SslEndpointOverride = input.ReadString(); + break; + } + case 34: { + SslRootCertsPem = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + AccessToken = input.ReadString(); + break; + } + case 16: { + UseSsl = input.ReadBool(); + break; + } + case 26: { + SslEndpointOverride = input.ReadString(); + break; + } + case 34: { + SslRootCertsPem = input.ReadString(); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// Response from test proxy service for CreateClientRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CreateClientResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CreateClientResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientResponse(CreateClientResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CreateClientResponse Clone() { + return new CreateClientResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CreateClientResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CreateClientResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CreateClientResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Request to test proxy service to close a client object. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CloseClientRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CloseClientRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientRequest(CloseClientRequest other) : this() { + clientId_ = other.clientId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientRequest Clone() { + return new CloseClientRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CloseClientRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CloseClientRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CloseClientRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for CloseClientRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CloseClientResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CloseClientResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientResponse(CloseClientResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CloseClientResponse Clone() { + return new CloseClientResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CloseClientResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CloseClientResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CloseClientResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Request to test proxy service to remove a client object. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RemoveClientRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RemoveClientRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientRequest(RemoveClientRequest other) : this() { + clientId_ = other.clientId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientRequest Clone() { + return new RemoveClientRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RemoveClientRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RemoveClientRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RemoveClientRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for RemoveClientRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RemoveClientResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RemoveClientResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientResponse(RemoveClientResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveClientResponse Clone() { + return new RemoveClientResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RemoveClientResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RemoveClientResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RemoveClientResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Request to test proxy service to read a row. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadRowRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadRowRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowRequest(ReadRowRequest other) : this() { + clientId_ = other.clientId_; + tableName_ = other.tableName_; + rowKey_ = other.rowKey_; + filter_ = other.filter_ != null ? other.filter_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowRequest Clone() { + return new ReadRowRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "table_name" field. + public const int TableNameFieldNumber = 4; + private string tableName_ = ""; + /// + /// The unique name of the table from which to read the row. + /// Values are of the form + /// `projects/<project>/instances/<instance>/tables/<table>`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TableName { + get { return tableName_; } + set { + tableName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "row_key" field. + public const int RowKeyFieldNumber = 2; + private string rowKey_ = ""; + /// + /// The row key of the target row. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RowKey { + get { return rowKey_; } + set { + rowKey_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "filter" field. + public const int FilterFieldNumber = 3; + private global::Google.Cloud.Bigtable.V2.RowFilter filter_; + /// + /// The row filter to be applied to the target row. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.RowFilter Filter { + get { return filter_; } + set { + filter_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadRowRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadRowRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (TableName != other.TableName) return false; + if (RowKey != other.RowKey) return false; + if (!object.Equals(Filter, other.Filter)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (TableName.Length != 0) hash ^= TableName.GetHashCode(); + if (RowKey.Length != 0) hash ^= RowKey.GetHashCode(); + if (filter_ != null) hash ^= Filter.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (RowKey.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RowKey); + } + if (filter_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Filter); + } + if (TableName.Length != 0) { + output.WriteRawTag(34); + output.WriteString(TableName); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (RowKey.Length != 0) { + output.WriteRawTag(18); + output.WriteString(RowKey); + } + if (filter_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Filter); + } + if (TableName.Length != 0) { + output.WriteRawTag(34); + output.WriteString(TableName); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (TableName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TableName); + } + if (RowKey.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RowKey); + } + if (filter_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Filter); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadRowRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.TableName.Length != 0) { + TableName = other.TableName; + } + if (other.RowKey.Length != 0) { + RowKey = other.RowKey; + } + if (other.filter_ != null) { + if (filter_ == null) { + Filter = new global::Google.Cloud.Bigtable.V2.RowFilter(); + } + Filter.MergeFrom(other.Filter); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + RowKey = input.ReadString(); + break; + } + case 26: { + if (filter_ == null) { + Filter = new global::Google.Cloud.Bigtable.V2.RowFilter(); + } + input.ReadMessage(Filter); + break; + } + case 34: { + TableName = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + RowKey = input.ReadString(); + break; + } + case 26: { + if (filter_ == null) { + Filter = new global::Google.Cloud.Bigtable.V2.RowFilter(); + } + input.ReadMessage(Filter); + break; + } + case 34: { + TableName = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for ReadRowRequest or + /// ReadModifyWriteRowRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RowResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RowResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowResult(RowResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + row_ = other.row_ != null ? other.row_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowResult Clone() { + return new RowResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "row" field. + public const int RowFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.Row row_; + /// + /// The contents of a single row. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.Row Row { + get { return row_; } + set { + row_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RowResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RowResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if (!object.Equals(Row, other.Row)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + if (row_ != null) hash ^= Row.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (row_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Row); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (row_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Row); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + if (row_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Row); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RowResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + if (other.row_ != null) { + if (row_ == null) { + Row = new global::Google.Cloud.Bigtable.V2.Row(); + } + Row.MergeFrom(other.Row); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (row_ == null) { + Row = new global::Google.Cloud.Bigtable.V2.Row(); + } + input.ReadMessage(Row); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (row_ == null) { + Row = new global::Google.Cloud.Bigtable.V2.Row(); + } + input.ReadMessage(Row); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to read rows. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadRowsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadRowsRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowsRequest(ReadRowsRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + cancelAfterRows_ = other.cancelAfterRows_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadRowsRequest Clone() { + return new ReadRowsRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.ReadRowsRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ReadRowsRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + /// Field number for the "cancel_after_rows" field. + public const int CancelAfterRowsFieldNumber = 3; + private int cancelAfterRows_; + /// + /// The streaming read can be canceled before all items are seen. + /// Has no effect if non-positive. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CancelAfterRows { + get { return cancelAfterRows_; } + set { + cancelAfterRows_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadRowsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadRowsRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + if (CancelAfterRows != other.CancelAfterRows) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (CancelAfterRows != 0) hash ^= CancelAfterRows.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (CancelAfterRows != 0) { + output.WriteRawTag(24); + output.WriteInt32(CancelAfterRows); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (CancelAfterRows != 0) { + output.WriteRawTag(24); + output.WriteInt32(CancelAfterRows); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (CancelAfterRows != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(CancelAfterRows); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadRowsRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadRowsRequest(); + } + Request.MergeFrom(other.Request); + } + if (other.CancelAfterRows != 0) { + CancelAfterRows = other.CancelAfterRows; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadRowsRequest(); + } + input.ReadMessage(Request); + break; + } + case 24: { + CancelAfterRows = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadRowsRequest(); + } + input.ReadMessage(Request); + break; + } + case 24: { + CancelAfterRows = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for ReadRowsRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RowsResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RowsResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowsResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowsResult(RowsResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + rows_ = other.rows_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RowsResult Clone() { + return new RowsResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "rows" field. + public const int RowsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_rows_codec + = pb::FieldCodec.ForMessage(18, global::Google.Cloud.Bigtable.V2.Row.Parser); + private readonly pbc::RepeatedField rows_ = new pbc::RepeatedField(); + /// + /// The contents of rows. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Rows { + get { return rows_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RowsResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RowsResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if(!rows_.Equals(other.rows_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + hash ^= rows_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + rows_.WriteTo(output, _repeated_rows_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + rows_.WriteTo(ref output, _repeated_rows_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + size += rows_.CalculateSize(_repeated_rows_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RowsResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + rows_.Add(other.rows_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + rows_.AddEntriesFrom(input, _repeated_rows_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + rows_.AddEntriesFrom(ref input, _repeated_rows_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to mutate a row. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class MutateRowRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MutateRowRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowRequest(MutateRowRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowRequest Clone() { + return new MutateRowRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.MutateRowRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.MutateRowRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as MutateRowRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(MutateRowRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(MutateRowRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for MutateRowRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class MutateRowResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MutateRowResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowResult(MutateRowResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowResult Clone() { + return new MutateRowResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as MutateRowResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(MutateRowResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(MutateRowResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to mutate rows. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class MutateRowsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MutateRowsRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsRequest(MutateRowsRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsRequest Clone() { + return new MutateRowsRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.MutateRowsRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.MutateRowsRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as MutateRowsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(MutateRowsRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(MutateRowsRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowsRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowsRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.MutateRowsRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for MutateRowsRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class MutateRowsResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new MutateRowsResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsResult(MutateRowsResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + entries_ = other.entries_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MutateRowsResult Clone() { + return new MutateRowsResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding, corresponding to the + /// whole operation. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "entries" field. + public const int EntriesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_entries_codec + = pb::FieldCodec.ForMessage(18, global::Google.Cloud.Bigtable.V2.MutateRowsResponse.Types.Entry.Parser); + private readonly pbc::RepeatedField entries_ = new pbc::RepeatedField(); + /// + /// The results corresponding to the failed rows. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Entries { + get { return entries_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as MutateRowsResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(MutateRowsResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if(!entries_.Equals(other.entries_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + hash ^= entries_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + entries_.WriteTo(output, _repeated_entries_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + entries_.WriteTo(ref output, _repeated_entries_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + size += entries_.CalculateSize(_repeated_entries_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(MutateRowsResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + entries_.Add(other.entries_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + entries_.AddEntriesFrom(input, _repeated_entries_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + entries_.AddEntriesFrom(ref input, _repeated_entries_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to check and mutate a row. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CheckAndMutateRowRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CheckAndMutateRowRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowRequest(CheckAndMutateRowRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowRequest Clone() { + return new CheckAndMutateRowRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.CheckAndMutateRowRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.CheckAndMutateRowRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CheckAndMutateRowRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CheckAndMutateRowRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CheckAndMutateRowRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for CheckAndMutateRowRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CheckAndMutateRowResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CheckAndMutateRowResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowResult(CheckAndMutateRowResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + result_ = other.result_ != null ? other.result_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CheckAndMutateRowResult Clone() { + return new CheckAndMutateRowResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "result" field. + public const int ResultFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.CheckAndMutateRowResponse result_; + /// + /// The raw response from the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.CheckAndMutateRowResponse Result { + get { return result_; } + set { + result_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CheckAndMutateRowResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CheckAndMutateRowResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if (!object.Equals(Result, other.Result)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + if (result_ != null) hash ^= Result.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (result_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Result); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (result_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Result); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + if (result_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Result); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CheckAndMutateRowResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + if (other.result_ != null) { + if (result_ == null) { + Result = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowResponse(); + } + Result.MergeFrom(other.Result); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (result_ == null) { + Result = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowResponse(); + } + input.ReadMessage(Result); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (result_ == null) { + Result = new global::Google.Cloud.Bigtable.V2.CheckAndMutateRowResponse(); + } + input.ReadMessage(Result); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to sample row keys. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SampleRowKeysRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SampleRowKeysRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysRequest(SampleRowKeysRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysRequest Clone() { + return new SampleRowKeysRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.SampleRowKeysRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.SampleRowKeysRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SampleRowKeysRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SampleRowKeysRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SampleRowKeysRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.SampleRowKeysRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.SampleRowKeysRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.SampleRowKeysRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for SampleRowKeysRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SampleRowKeysResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SampleRowKeysResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysResult(SampleRowKeysResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + samples_ = other.samples_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SampleRowKeysResult Clone() { + return new SampleRowKeysResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "samples" field. + public const int SamplesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_samples_codec + = pb::FieldCodec.ForMessage(18, global::Google.Cloud.Bigtable.V2.SampleRowKeysResponse.Parser); + private readonly pbc::RepeatedField samples_ = new pbc::RepeatedField(); + /// + /// The raw responses from the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Samples { + get { return samples_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SampleRowKeysResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SampleRowKeysResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if(!samples_.Equals(other.samples_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + hash ^= samples_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + samples_.WriteTo(output, _repeated_samples_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + samples_.WriteTo(ref output, _repeated_samples_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + size += samples_.CalculateSize(_repeated_samples_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SampleRowKeysResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + samples_.Add(other.samples_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + samples_.AddEntriesFrom(input, _repeated_samples_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + samples_.AddEntriesFrom(ref input, _repeated_samples_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to read modify write a row. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadModifyWriteRowRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadModifyWriteRowRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadModifyWriteRowRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadModifyWriteRowRequest(ReadModifyWriteRowRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadModifyWriteRowRequest Clone() { + return new ReadModifyWriteRowRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.ReadModifyWriteRowRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ReadModifyWriteRowRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadModifyWriteRowRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadModifyWriteRowRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadModifyWriteRowRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadModifyWriteRowRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadModifyWriteRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ReadModifyWriteRowRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Request to test proxy service to execute a query. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ExecuteQueryRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExecuteQueryRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryRequest(ExecuteQueryRequest other) : this() { + clientId_ = other.clientId_; + request_ = other.request_ != null ? other.request_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryRequest Clone() { + return new ExecuteQueryRequest(this); + } + + /// Field number for the "client_id" field. + public const int ClientIdFieldNumber = 1; + private string clientId_ = ""; + /// + /// The ID of the target client object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ClientId { + get { return clientId_; } + set { + clientId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "request" field. + public const int RequestFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.ExecuteQueryRequest request_; + /// + /// The raw request to the Bigtable server. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ExecuteQueryRequest Request { + get { return request_; } + set { + request_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ExecuteQueryRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ExecuteQueryRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ClientId != other.ClientId) return false; + if (!object.Equals(Request, other.Request)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ClientId.Length != 0) hash ^= ClientId.GetHashCode(); + if (request_ != null) hash ^= Request.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ClientId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ClientId); + } + if (request_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Request); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ClientId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ClientId); + } + if (request_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Request); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ExecuteQueryRequest other) { + if (other == null) { + return; + } + if (other.ClientId.Length != 0) { + ClientId = other.ClientId; + } + if (other.request_ != null) { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ExecuteQueryRequest(); + } + Request.MergeFrom(other.Request); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ExecuteQueryRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ClientId = input.ReadString(); + break; + } + case 18: { + if (request_ == null) { + Request = new global::Google.Cloud.Bigtable.V2.ExecuteQueryRequest(); + } + input.ReadMessage(Request); + break; + } + } + } + } + #endif + + } + + /// + /// Response from test proxy service for ExecuteQueryRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ExecuteQueryResult : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExecuteQueryResult()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryResult() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryResult(ExecuteQueryResult other) : this() { + status_ = other.status_ != null ? other.status_.Clone() : null; + resultSetMetadata_ = other.resultSetMetadata_ != null ? other.resultSetMetadata_.Clone() : null; + metadata_ = other.metadata_ != null ? other.metadata_.Clone() : null; + rows_ = other.rows_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExecuteQueryResult Clone() { + return new ExecuteQueryResult(this); + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 1; + private global::Google.Rpc.Status status_; + /// + /// The RPC status from the client binding. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Rpc.Status Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "result_set_metadata" field. + public const int ResultSetMetadataFieldNumber = 2; + private global::Google.Cloud.Bigtable.V2.ResultSetMetadata resultSetMetadata_; + /// + /// deprecated + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ResultSetMetadata ResultSetMetadata { + get { return resultSetMetadata_; } + set { + resultSetMetadata_ = value; + } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 4; + private global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata metadata_; + /// + /// Name and type information for the query result. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata Metadata { + get { return metadata_; } + set { + metadata_ = value; + } + } + + /// Field number for the "rows" field. + public const int RowsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_rows_codec + = pb::FieldCodec.ForMessage(26, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SqlRow.Parser); + private readonly pbc::RepeatedField rows_ = new pbc::RepeatedField(); + /// + /// Encoded version of the ResultSet. Should not contain type information. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Rows { + get { return rows_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ExecuteQueryResult); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ExecuteQueryResult other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Status, other.Status)) return false; + if (!object.Equals(ResultSetMetadata, other.ResultSetMetadata)) return false; + if (!object.Equals(Metadata, other.Metadata)) return false; + if(!rows_.Equals(other.rows_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (status_ != null) hash ^= Status.GetHashCode(); + if (resultSetMetadata_ != null) hash ^= ResultSetMetadata.GetHashCode(); + if (metadata_ != null) hash ^= Metadata.GetHashCode(); + hash ^= rows_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (resultSetMetadata_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ResultSetMetadata); + } + rows_.WriteTo(output, _repeated_rows_codec); + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (status_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Status); + } + if (resultSetMetadata_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ResultSetMetadata); + } + rows_.WriteTo(ref output, _repeated_rows_codec); + if (metadata_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Metadata); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (status_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Status); + } + if (resultSetMetadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ResultSetMetadata); + } + if (metadata_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Metadata); + } + size += rows_.CalculateSize(_repeated_rows_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ExecuteQueryResult other) { + if (other == null) { + return; + } + if (other.status_ != null) { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + Status.MergeFrom(other.Status); + } + if (other.resultSetMetadata_ != null) { + if (resultSetMetadata_ == null) { + ResultSetMetadata = new global::Google.Cloud.Bigtable.V2.ResultSetMetadata(); + } + ResultSetMetadata.MergeFrom(other.ResultSetMetadata); + } + if (other.metadata_ != null) { + if (metadata_ == null) { + Metadata = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata(); + } + Metadata.MergeFrom(other.Metadata); + } + rows_.Add(other.rows_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (resultSetMetadata_ == null) { + ResultSetMetadata = new global::Google.Cloud.Bigtable.V2.ResultSetMetadata(); + } + input.ReadMessage(ResultSetMetadata); + break; + } + case 26: { + rows_.AddEntriesFrom(input, _repeated_rows_codec); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata(); + } + input.ReadMessage(Metadata); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (status_ == null) { + Status = new global::Google.Rpc.Status(); + } + input.ReadMessage(Status); + break; + } + case 18: { + if (resultSetMetadata_ == null) { + ResultSetMetadata = new global::Google.Cloud.Bigtable.V2.ResultSetMetadata(); + } + input.ReadMessage(ResultSetMetadata); + break; + } + case 26: { + rows_.AddEntriesFrom(ref input, _repeated_rows_codec); + break; + } + case 34: { + if (metadata_ == null) { + Metadata = new global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ResultSetMetadata(); + } + input.ReadMessage(Metadata); + break; + } + } + } + } + #endif + + } + + /// + /// Schema information for the query result. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ResultSetMetadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ResultSetMetadata()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultSetMetadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultSetMetadata(ResultSetMetadata other) : this() { + columns_ = other.columns_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultSetMetadata Clone() { + return new ResultSetMetadata(this); + } + + /// Field number for the "columns" field. + public const int ColumnsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_columns_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Bigtable.V2.ColumnMetadata.Parser); + private readonly pbc::RepeatedField columns_ = new pbc::RepeatedField(); + /// + /// Column metadata for each column inthe query result. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Columns { + get { return columns_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ResultSetMetadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ResultSetMetadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!columns_.Equals(other.columns_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= columns_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + columns_.WriteTo(output, _repeated_columns_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + columns_.WriteTo(ref output, _repeated_columns_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += columns_.CalculateSize(_repeated_columns_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ResultSetMetadata other) { + if (other == null) { + return; + } + columns_.Add(other.columns_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + columns_.AddEntriesFrom(input, _repeated_columns_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + columns_.AddEntriesFrom(ref input, _repeated_columns_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Representation of a single row in the query result. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SqlRow : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SqlRow()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.MessageTypes[22]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SqlRow() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SqlRow(SqlRow other) : this() { + values_ = other.values_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SqlRow Clone() { + return new SqlRow(this); + } + + /// Field number for the "values" field. + public const int ValuesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_values_codec + = pb::FieldCodec.ForMessage(10, global::Google.Cloud.Bigtable.V2.Value.Parser); + private readonly pbc::RepeatedField values_ = new pbc::RepeatedField(); + /// + /// Columnar values returned by the query. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Values { + get { return values_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SqlRow); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SqlRow other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!values_.Equals(other.values_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= values_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + values_.WriteTo(output, _repeated_values_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + values_.WriteTo(ref output, _repeated_values_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += values_.CalculateSize(_repeated_values_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SqlRow other) { + if (other == null) { + return; + } + values_.Add(other.values_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + values_.AddEntriesFrom(input, _repeated_values_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + values_.AddEntriesFrom(ref input, _repeated_values_codec); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxyGrpc.g.cs b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxyGrpc.g.cs new file mode 100644 index 000000000000..9347e88ebfe8 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/TestProxyGrpc.g.cs @@ -0,0 +1,1020 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: test_proxy.proto +// +// Original file comments: +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#pragma warning disable 0414, 1591, 8981, 0612 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy { + /// + /// Note that all RPCs are unary, even when the equivalent client binding call + /// may be streaming. This is an intentional simplification. + /// + /// Most methods have sync (default) and async variants. For async variants, + /// the proxy is expected to perform the async operation, then wait for results + /// before delivering them back to the driver client. + /// + /// Operations that may have interesting concurrency characteristics are + /// represented explicitly in the API (see ReadRowsRequest.cancel_after_rows). + /// We include such operations only when they can be meaningfully performed + /// through client bindings. + /// + /// Users should generally avoid setting deadlines for requests to the Proxy + /// because operations are not cancelable. If the deadline is set anyway, please + /// understand that the underlying operation will continue to be executed even + /// after the deadline expires. + /// + public static partial class CloudBigtableV2TestProxy + { + static readonly string __ServiceName = "google.bigtable.testproxy.CloudBigtableV2TestProxy"; + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context) + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (message is global::Google.Protobuf.IBufferMessage) + { + context.SetPayloadLength(message.CalculateSize()); + global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter()); + context.Complete(); + return; + } + #endif + context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static class __Helper_MessageCache + { + public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static T __Helper_DeserializeMessage(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser parser) where T : global::Google.Protobuf.IMessage + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (__Helper_MessageCache.IsBufferMessage) + { + return parser.ParseFrom(context.PayloadAsReadOnlySequence()); + } + #endif + return parser.ParseFrom(context.PayloadAsNewBuffer()); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CreateClientRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CreateClientResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CloseClientRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CloseClientResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_RemoveClientRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_RemoveClientResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientResponse.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_ReadRowRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_RowResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_ReadRowsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_RowsResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowsResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_MutateRowRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_MutateRowResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_MutateRowsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_MutateRowsResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CheckAndMutateRowRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_CheckAndMutateRowResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_SampleRowKeysRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_SampleRowKeysResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysResult.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_ReadModifyWriteRowRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_ExecuteQueryRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_google_bigtable_testproxy_ExecuteQueryResult = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryResult.Parser)); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_CreateClient = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "CreateClient", + __Marshaller_google_bigtable_testproxy_CreateClientRequest, + __Marshaller_google_bigtable_testproxy_CreateClientResponse); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_CloseClient = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "CloseClient", + __Marshaller_google_bigtable_testproxy_CloseClientRequest, + __Marshaller_google_bigtable_testproxy_CloseClientResponse); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_RemoveClient = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "RemoveClient", + __Marshaller_google_bigtable_testproxy_RemoveClientRequest, + __Marshaller_google_bigtable_testproxy_RemoveClientResponse); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ReadRow = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ReadRow", + __Marshaller_google_bigtable_testproxy_ReadRowRequest, + __Marshaller_google_bigtable_testproxy_RowResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ReadRows = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ReadRows", + __Marshaller_google_bigtable_testproxy_ReadRowsRequest, + __Marshaller_google_bigtable_testproxy_RowsResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_MutateRow = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "MutateRow", + __Marshaller_google_bigtable_testproxy_MutateRowRequest, + __Marshaller_google_bigtable_testproxy_MutateRowResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_BulkMutateRows = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "BulkMutateRows", + __Marshaller_google_bigtable_testproxy_MutateRowsRequest, + __Marshaller_google_bigtable_testproxy_MutateRowsResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_CheckAndMutateRow = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "CheckAndMutateRow", + __Marshaller_google_bigtable_testproxy_CheckAndMutateRowRequest, + __Marshaller_google_bigtable_testproxy_CheckAndMutateRowResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_SampleRowKeys = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "SampleRowKeys", + __Marshaller_google_bigtable_testproxy_SampleRowKeysRequest, + __Marshaller_google_bigtable_testproxy_SampleRowKeysResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ReadModifyWriteRow = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ReadModifyWriteRow", + __Marshaller_google_bigtable_testproxy_ReadModifyWriteRowRequest, + __Marshaller_google_bigtable_testproxy_RowResult); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteQuery = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteQuery", + __Marshaller_google_bigtable_testproxy_ExecuteQueryRequest, + __Marshaller_google_bigtable_testproxy_ExecuteQueryResult); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.TestProxyReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of CloudBigtableV2TestProxy + [grpc::BindServiceMethod(typeof(CloudBigtableV2TestProxy), "BindService")] + public abstract partial class CloudBigtableV2TestProxyBase + { + /// + /// Client management: + /// + /// Creates a client in the proxy. + /// Each client has its own dedicated channel(s), and can be used concurrently + /// and independently with other clients. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task CreateClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Closes a client in the proxy, making it not accept new requests. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task CloseClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Removes a client in the proxy, making it inaccessible. Client closing + /// should be done by CloseClient() separately. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task RemoveClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Bigtable operations: for each operation, you should use the synchronous or + /// asynchronous variant of the client method based on the `use_async_method` + /// setting of the client instance. For starters, you can choose to implement + /// one variant, and return UNIMPLEMENTED status for the other. + /// + /// Reads a row with the client instance. + /// The result row may not be present in the response. + /// Callers should check for it (e.g. calling has_row() in C++). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ReadRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Reads rows with the client instance. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ReadRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Writes a row with the client instance. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task MutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Writes multiple rows with the client instance. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task BulkMutateRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Performs a check-and-mutate-row operation with the client instance. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task CheckAndMutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Obtains a row key sampling with the client instance. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task SampleRowKeys(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Performs a read-modify-write operation with the client. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ReadModifyWriteRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Executes a BTQL query with the client. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteQuery(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for CloudBigtableV2TestProxy + public partial class CloudBigtableV2TestProxyClient : grpc::ClientBase + { + /// Creates a new client for CloudBigtableV2TestProxy + /// The channel to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public CloudBigtableV2TestProxyClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for CloudBigtableV2TestProxy that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public CloudBigtableV2TestProxyClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected CloudBigtableV2TestProxyClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected CloudBigtableV2TestProxyClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + /// + /// Client management: + /// + /// Creates a client in the proxy. + /// Each client has its own dedicated channel(s), and can be used concurrently + /// and independently with other clients. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientResponse CreateClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CreateClient(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Client management: + /// + /// Creates a client in the proxy. + /// Each client has its own dedicated channel(s), and can be used concurrently + /// and independently with other clients. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientResponse CreateClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_CreateClient, null, options, request); + } + /// + /// Client management: + /// + /// Creates a client in the proxy. + /// Each client has its own dedicated channel(s), and can be used concurrently + /// and independently with other clients. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CreateClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CreateClientAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Client management: + /// + /// Creates a client in the proxy. + /// Each client has its own dedicated channel(s), and can be used concurrently + /// and independently with other clients. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CreateClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CreateClientRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_CreateClient, null, options, request); + } + /// + /// Closes a client in the proxy, making it not accept new requests. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientResponse CloseClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CloseClient(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Closes a client in the proxy, making it not accept new requests. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientResponse CloseClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_CloseClient, null, options, request); + } + /// + /// Closes a client in the proxy, making it not accept new requests. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CloseClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CloseClientAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Closes a client in the proxy, making it not accept new requests. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CloseClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CloseClientRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_CloseClient, null, options, request); + } + /// + /// Removes a client in the proxy, making it inaccessible. Client closing + /// should be done by CloseClient() separately. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientResponse RemoveClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return RemoveClient(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Removes a client in the proxy, making it inaccessible. Client closing + /// should be done by CloseClient() separately. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientResponse RemoveClient(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_RemoveClient, null, options, request); + } + /// + /// Removes a client in the proxy, making it inaccessible. Client closing + /// should be done by CloseClient() separately. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall RemoveClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return RemoveClientAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Removes a client in the proxy, making it inaccessible. Client closing + /// should be done by CloseClient() separately. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall RemoveClientAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RemoveClientRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_RemoveClient, null, options, request); + } + /// + /// Bigtable operations: for each operation, you should use the synchronous or + /// asynchronous variant of the client method based on the `use_async_method` + /// setting of the client instance. For starters, you can choose to implement + /// one variant, and return UNIMPLEMENTED status for the other. + /// + /// Reads a row with the client instance. + /// The result row may not be present in the response. + /// Callers should check for it (e.g. calling has_row() in C++). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult ReadRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadRow(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Bigtable operations: for each operation, you should use the synchronous or + /// asynchronous variant of the client method based on the `use_async_method` + /// setting of the client instance. For starters, you can choose to implement + /// one variant, and return UNIMPLEMENTED status for the other. + /// + /// Reads a row with the client instance. + /// The result row may not be present in the response. + /// Callers should check for it (e.g. calling has_row() in C++). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult ReadRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ReadRow, null, options, request); + } + /// + /// Bigtable operations: for each operation, you should use the synchronous or + /// asynchronous variant of the client method based on the `use_async_method` + /// setting of the client instance. For starters, you can choose to implement + /// one variant, and return UNIMPLEMENTED status for the other. + /// + /// Reads a row with the client instance. + /// The result row may not be present in the response. + /// Callers should check for it (e.g. calling has_row() in C++). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadRowAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Bigtable operations: for each operation, you should use the synchronous or + /// asynchronous variant of the client method based on the `use_async_method` + /// setting of the client instance. For starters, you can choose to implement + /// one variant, and return UNIMPLEMENTED status for the other. + /// + /// Reads a row with the client instance. + /// The result row may not be present in the response. + /// Callers should check for it (e.g. calling has_row() in C++). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ReadRow, null, options, request); + } + /// + /// Reads rows with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowsResult ReadRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadRows(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Reads rows with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowsResult ReadRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ReadRows, null, options, request); + } + /// + /// Reads rows with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadRowsAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadRowsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Reads rows with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadRowsAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadRowsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ReadRows, null, options, request); + } + /// + /// Writes a row with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowResult MutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return MutateRow(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Writes a row with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowResult MutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_MutateRow, null, options, request); + } + /// + /// Writes a row with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall MutateRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return MutateRowAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Writes a row with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall MutateRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_MutateRow, null, options, request); + } + /// + /// Writes multiple rows with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsResult BulkMutateRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return BulkMutateRows(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Writes multiple rows with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsResult BulkMutateRows(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_BulkMutateRows, null, options, request); + } + /// + /// Writes multiple rows with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall BulkMutateRowsAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return BulkMutateRowsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Writes multiple rows with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall BulkMutateRowsAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.MutateRowsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_BulkMutateRows, null, options, request); + } + /// + /// Performs a check-and-mutate-row operation with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowResult CheckAndMutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CheckAndMutateRow(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Performs a check-and-mutate-row operation with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowResult CheckAndMutateRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_CheckAndMutateRow, null, options, request); + } + /// + /// Performs a check-and-mutate-row operation with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CheckAndMutateRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return CheckAndMutateRowAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Performs a check-and-mutate-row operation with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall CheckAndMutateRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.CheckAndMutateRowRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_CheckAndMutateRow, null, options, request); + } + /// + /// Obtains a row key sampling with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysResult SampleRowKeys(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return SampleRowKeys(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Obtains a row key sampling with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysResult SampleRowKeys(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_SampleRowKeys, null, options, request); + } + /// + /// Obtains a row key sampling with the client instance. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall SampleRowKeysAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return SampleRowKeysAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Obtains a row key sampling with the client instance. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall SampleRowKeysAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.SampleRowKeysRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_SampleRowKeys, null, options, request); + } + /// + /// Performs a read-modify-write operation with the client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult ReadModifyWriteRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadModifyWriteRow(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Performs a read-modify-write operation with the client. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.RowResult ReadModifyWriteRow(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ReadModifyWriteRow, null, options, request); + } + /// + /// Performs a read-modify-write operation with the client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadModifyWriteRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ReadModifyWriteRowAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Performs a read-modify-write operation with the client. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ReadModifyWriteRowAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ReadModifyWriteRowRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ReadModifyWriteRow, null, options, request); + } + /// + /// Executes a BTQL query with the client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryResult ExecuteQuery(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteQuery(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Executes a BTQL query with the client. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryResult ExecuteQuery(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteQuery, null, options, request); + } + /// + /// Executes a BTQL query with the client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteQueryAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteQueryAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Executes a BTQL query with the client. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteQueryAsync(global::Google.Cloud.Bigtable.V2.ConformanceTests.TestProxy.ExecuteQueryRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteQuery, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected override CloudBigtableV2TestProxyClient NewInstance(ClientBaseConfiguration configuration) + { + return new CloudBigtableV2TestProxyClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static grpc::ServerServiceDefinition BindService(CloudBigtableV2TestProxyBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_CreateClient, serviceImpl.CreateClient) + .AddMethod(__Method_CloseClient, serviceImpl.CloseClient) + .AddMethod(__Method_RemoveClient, serviceImpl.RemoveClient) + .AddMethod(__Method_ReadRow, serviceImpl.ReadRow) + .AddMethod(__Method_ReadRows, serviceImpl.ReadRows) + .AddMethod(__Method_MutateRow, serviceImpl.MutateRow) + .AddMethod(__Method_BulkMutateRows, serviceImpl.BulkMutateRows) + .AddMethod(__Method_CheckAndMutateRow, serviceImpl.CheckAndMutateRow) + .AddMethod(__Method_SampleRowKeys, serviceImpl.SampleRowKeys) + .AddMethod(__Method_ReadModifyWriteRow, serviceImpl.ReadModifyWriteRow) + .AddMethod(__Method_ExecuteQuery, serviceImpl.ExecuteQuery).Build(); + } + + /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. + /// Note: this method is part of an experimental API that can change or be removed without any prior notice. + /// Service methods will be bound by calling AddMethod on this object. + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static void BindService(grpc::ServiceBinderBase serviceBinder, CloudBigtableV2TestProxyBase serviceImpl) + { + serviceBinder.AddMethod(__Method_CreateClient, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CreateClient)); + serviceBinder.AddMethod(__Method_CloseClient, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CloseClient)); + serviceBinder.AddMethod(__Method_RemoveClient, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.RemoveClient)); + serviceBinder.AddMethod(__Method_ReadRow, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ReadRow)); + serviceBinder.AddMethod(__Method_ReadRows, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ReadRows)); + serviceBinder.AddMethod(__Method_MutateRow, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.MutateRow)); + serviceBinder.AddMethod(__Method_BulkMutateRows, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.BulkMutateRows)); + serviceBinder.AddMethod(__Method_CheckAndMutateRow, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.CheckAndMutateRow)); + serviceBinder.AddMethod(__Method_SampleRowKeys, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.SampleRowKeys)); + serviceBinder.AddMethod(__Method_ReadModifyWriteRow, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ReadModifyWriteRow)); + serviceBinder.AddMethod(__Method_ExecuteQuery, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteQuery)); + } + + } +} +#endregion diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/appsettings.json b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/appsettings.json new file mode 100644 index 000000000000..ce8fe25e71bb --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/appsettings.json @@ -0,0 +1,19 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*", + "Kestrel": { + "EndpointDefaults": { + "Protocols": "Http2" + }, + "Endpoints": { + "TestEndpoint": { + "Url": "http://localhost:7238" + } + } + } +} diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/bigtable-conformance.sh b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/bigtable-conformance.sh new file mode 100644 index 000000000000..ae12f38f8e21 --- /dev/null +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests/bigtable-conformance.sh @@ -0,0 +1,49 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +#!/bin/bash + +set -eo pipefail + +## cd to the parent directory, i.e. the root of the git repo +cd ./ + +RETURN_CODE=0 + +# Build the proxy +pushd . +cd apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.ConformanceTests +dotnet build +# Start the proxy in a separate process +dotnet run & +popd + +pushd . +cd cloud-bigtable-clients-test/tests +# Cookie, RetryInfo, ExecuteQuery, ReverseScans and FeatureGap are known failures of new features that we don't yet support. +# CloseClient we don't support as expected, but we support it in a valid manner. +# For the others we have issues to investigate, see comments in b/372509076 . +eval "go test -v -proxy_addr=:7238 -skip _Retry_WithRoutingCookie\|_Retry_WithRetryInfo\|_CloseClient\|_ReverseScans\|TestFeatureGap\|TestExecuteQuery\|TestReadRows_NoRetry_ErrorAfterLastRow\|TestReadRows_Retry_PausedScan\|TestReadRows_Retry_LastScannedRow_Reverse\|TestReadRow_Generic_DeadlineExceeded" +returnCode=$? +popd + +if [[ ${returnCode} -gt 0 ]] +then + echo "Conformance test failed" + RETURN_CODE=${returnCode} +else + echo "Conformance test passed" +fi + +exit ${RETURN_CODE} \ No newline at end of file diff --git a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.sln b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.sln index 37ab79a4641e..7e37e15e42ad 100644 --- a/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.sln +++ b/apis/Google.Cloud.Bigtable.V2/Google.Cloud.Bigtable.V2.sln @@ -15,6 +15,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Google.Cloud.Bigtable.V2.Te EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Google.Cloud.ClientTesting", "..\..\tools\Google.Cloud.ClientTesting\Google.Cloud.ClientTesting.csproj", "{29974B0C-A7B0-8CA8-AE32-99F622C89044}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Google.Cloud.Bigtable.V2.ConformanceTests", "Google.Cloud.Bigtable.V2.ConformanceTests\Google.Cloud.Bigtable.V2.ConformanceTests.csproj", "{376D5F49-0F59-402A-8F37-D51B0F511887}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -45,6 +47,10 @@ Global {29974B0C-A7B0-8CA8-AE32-99F622C89044}.Debug|Any CPU.Build.0 = Debug|Any CPU {29974B0C-A7B0-8CA8-AE32-99F622C89044}.Release|Any CPU.ActiveCfg = Release|Any CPU {29974B0C-A7B0-8CA8-AE32-99F622C89044}.Release|Any CPU.Build.0 = Release|Any CPU + {376D5F49-0F59-402A-8F37-D51B0F511887}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {376D5F49-0F59-402A-8F37-D51B0F511887}.Debug|Any CPU.Build.0 = Debug|Any CPU + {376D5F49-0F59-402A-8F37-D51B0F511887}.Release|Any CPU.ActiveCfg = Release|Any CPU + {376D5F49-0F59-402A-8F37-D51B0F511887}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE