diff --git a/Jaeger.sln b/Jaeger.sln index 760eaef4e..afc775825 100644 --- a/Jaeger.sln +++ b/Jaeger.sln @@ -46,6 +46,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jaeger.Senders.Grpc.Tests", EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Communication", "Communication", "{30786A14-F882-410B-A74D-BF608B05340A}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jaeger.Communication.Grpc", "src\Communication\Jaeger.Communication.Grpc\Jaeger.Communication.Grpc.csproj", "{F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jaeger.Communication.Thrift", "src\Communication\Jaeger.Communication.Thrift\Jaeger.Communication.Thrift.csproj", "{4521D9CB-C7E6-4C38-AA34-035EC7DC41E0}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{22F94D42-FF84-4B15-8762-C95ACC8D1FE5}" @@ -181,6 +183,18 @@ Global {6943F8EA-233C-408D-8145-923D5CDF6852}.Release|x64.Build.0 = Release|Any CPU {6943F8EA-233C-408D-8145-923D5CDF6852}.Release|x86.ActiveCfg = Release|Any CPU {6943F8EA-233C-408D-8145-923D5CDF6852}.Release|x86.Build.0 = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|x64.ActiveCfg = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|x64.Build.0 = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|x86.ActiveCfg = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Debug|x86.Build.0 = Debug|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|Any CPU.Build.0 = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|x64.ActiveCfg = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|x64.Build.0 = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|x86.ActiveCfg = Release|Any CPU + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD}.Release|x86.Build.0 = Release|Any CPU {4521D9CB-C7E6-4C38-AA34-035EC7DC41E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4521D9CB-C7E6-4C38-AA34-035EC7DC41E0}.Debug|Any CPU.Build.0 = Debug|Any CPU {4521D9CB-C7E6-4C38-AA34-035EC7DC41E0}.Debug|x64.ActiveCfg = Debug|Any CPU @@ -211,6 +225,7 @@ Global {FFB09FE3-BEDD-49F4-93D2-C38CC1357D09} = {A608712F-64B9-49AA-B688-81B7A49436B7} {6943F8EA-233C-408D-8145-923D5CDF6852} = {B79DA458-94D5-4BF6-9934-27E0AC24F604} {30786A14-F882-410B-A74D-BF608B05340A} = {4FB0DAC9-D8C6-4368-B48E-363FA85029A4} + {F3D39D28-6AAE-4FAA-9C80-A200CFFEA1BD} = {30786A14-F882-410B-A74D-BF608B05340A} {4521D9CB-C7E6-4C38-AA34-035EC7DC41E0} = {30786A14-F882-410B-A74D-BF608B05340A} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution diff --git a/src/Communication/Jaeger.Communication.Grpc/CollectorGrpc.cs b/src/Communication/Jaeger.Communication.Grpc/CollectorGrpc.cs new file mode 100644 index 000000000..685065976 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/CollectorGrpc.cs @@ -0,0 +1,123 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: collector.proto +// +// Original file comments: +// Copyright (c) 2019 The Jaeger Authors. +// Copyright (c) 2018 Uber Technologies, Inc. +// +// 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 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Jaeger.ApiV2 { + public static partial class CollectorService + { + static readonly string __ServiceName = "jaeger.api_v2.CollectorService"; + + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_PostSpansRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.PostSpansRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_PostSpansResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.PostSpansResponse.Parser.ParseFrom); + + static readonly grpc::Method __Method_PostSpans = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "PostSpans", + __Marshaller_jaeger_api_v2_PostSpansRequest, + __Marshaller_jaeger_api_v2_PostSpansResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Jaeger.ApiV2.CollectorReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of CollectorService + [grpc::BindServiceMethod(typeof(CollectorService), "BindService")] + public abstract partial class CollectorServiceBase + { + public virtual global::System.Threading.Tasks.Task PostSpans(global::Jaeger.ApiV2.PostSpansRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for CollectorService + public partial class CollectorServiceClient : grpc::ClientBase + { + /// Creates a new client for CollectorService + /// The channel to use to make remote calls. + public CollectorServiceClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for CollectorService that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + public CollectorServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + protected CollectorServiceClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + protected CollectorServiceClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + public virtual global::Jaeger.ApiV2.PostSpansResponse PostSpans(global::Jaeger.ApiV2.PostSpansRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return PostSpans(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.PostSpansResponse PostSpans(global::Jaeger.ApiV2.PostSpansRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_PostSpans, null, options, request); + } + public virtual grpc::AsyncUnaryCall PostSpansAsync(global::Jaeger.ApiV2.PostSpansRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return PostSpansAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall PostSpansAsync(global::Jaeger.ApiV2.PostSpansRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_PostSpans, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + protected override CollectorServiceClient NewInstance(ClientBaseConfiguration configuration) + { + return new CollectorServiceClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + public static grpc::ServerServiceDefinition BindService(CollectorServiceBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_PostSpans, serviceImpl.PostSpans).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. + public static void BindService(grpc::ServiceBinderBase serviceBinder, CollectorServiceBase serviceImpl) + { + serviceBinder.AddMethod(__Method_PostSpans, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.PostSpans)); + } + + } +} +#endregion diff --git a/src/Communication/Jaeger.Communication.Grpc/Gogoproto/Gogo.cs b/src/Communication/Jaeger.Communication.Grpc/Gogoproto/Gogo.cs new file mode 100644 index 000000000..6c8b04b72 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Gogoproto/Gogo.cs @@ -0,0 +1,291 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: gogoproto/gogo.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Gogoproto { + + /// Holder for reflection information generated from gogoproto/gogo.proto + internal static partial class GogoReflection { + + #region Descriptor + /// File descriptor for gogoproto/gogo.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static GogoReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChRnb2dvcHJvdG8vZ29nby5wcm90bxIJZ29nb3Byb3RvGiBnb29nbGUvcHJv", + "dG9idWYvZGVzY3JpcHRvci5wcm90bzo7ChNnb3Byb3RvX2VudW1fcHJlZml4", + "EhwuZ29vZ2xlLnByb3RvYnVmLkVudW1PcHRpb25zGLHkAyABKAg6PQoVZ29w", + "cm90b19lbnVtX3N0cmluZ2VyEhwuZ29vZ2xlLnByb3RvYnVmLkVudW1PcHRp", + "b25zGMXkAyABKAg6NQoNZW51bV9zdHJpbmdlchIcLmdvb2dsZS5wcm90b2J1", + "Zi5FbnVtT3B0aW9ucxjG5AMgASgIOjcKD2VudW1fY3VzdG9tbmFtZRIcLmdv", + "b2dsZS5wcm90b2J1Zi5FbnVtT3B0aW9ucxjH5AMgASgJOjAKCGVudW1kZWNs", + "EhwuZ29vZ2xlLnByb3RvYnVmLkVudW1PcHRpb25zGMjkAyABKAg6QQoUZW51", + "bXZhbHVlX2N1c3RvbW5hbWUSIS5nb29nbGUucHJvdG9idWYuRW51bVZhbHVl", + "T3B0aW9ucxjRgwQgASgJOjsKE2dvcHJvdG9fZ2V0dGVyc19hbGwSHC5nb29n", + "bGUucHJvdG9idWYuRmlsZU9wdGlvbnMYmewDIAEoCDo/Chdnb3Byb3RvX2Vu", + "dW1fcHJlZml4X2FsbBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxia", + "7AMgASgIOjwKFGdvcHJvdG9fc3RyaW5nZXJfYWxsEhwuZ29vZ2xlLnByb3Rv", + "YnVmLkZpbGVPcHRpb25zGJvsAyABKAg6OQoRdmVyYm9zZV9lcXVhbF9hbGwS", + "HC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMYnOwDIAEoCDowCghmYWNl", + "X2FsbBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxid7AMgASgIOjQK", + "DGdvc3RyaW5nX2FsbBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxie", + "7AMgASgIOjQKDHBvcHVsYXRlX2FsbBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxl", + "T3B0aW9ucxif7AMgASgIOjQKDHN0cmluZ2VyX2FsbBIcLmdvb2dsZS5wcm90", + "b2J1Zi5GaWxlT3B0aW9ucxig7AMgASgIOjMKC29ubHlvbmVfYWxsEhwuZ29v", + "Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKHsAyABKAg6MQoJZXF1YWxfYWxs", + "EhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKXsAyABKAg6NwoPZGVz", + "Y3JpcHRpb25fYWxsEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKbs", + "AyABKAg6MwoLdGVzdGdlbl9hbGwSHC5nb29nbGUucHJvdG9idWYuRmlsZU9w", + "dGlvbnMYp+wDIAEoCDo0CgxiZW5jaGdlbl9hbGwSHC5nb29nbGUucHJvdG9i", + "dWYuRmlsZU9wdGlvbnMYqOwDIAEoCDo1Cg1tYXJzaGFsZXJfYWxsEhwuZ29v", + "Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKnsAyABKAg6NwoPdW5tYXJzaGFs", + "ZXJfYWxsEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKrsAyABKAg6", + "PAoUc3RhYmxlX21hcnNoYWxlcl9hbGwSHC5nb29nbGUucHJvdG9idWYuRmls", + "ZU9wdGlvbnMYq+wDIAEoCDoxCglzaXplcl9hbGwSHC5nb29nbGUucHJvdG9i", + "dWYuRmlsZU9wdGlvbnMYrOwDIAEoCDpBChlnb3Byb3RvX2VudW1fc3RyaW5n", + "ZXJfYWxsEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGK3sAyABKAg6", + "OQoRZW51bV9zdHJpbmdlcl9hbGwSHC5nb29nbGUucHJvdG9idWYuRmlsZU9w", + "dGlvbnMYruwDIAEoCDo8ChR1bnNhZmVfbWFyc2hhbGVyX2FsbBIcLmdvb2ds", + "ZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxiv7AMgASgIOj4KFnVuc2FmZV91bm1h", + "cnNoYWxlcl9hbGwSHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMYsOwD", + "IAEoCDpCChpnb3Byb3RvX2V4dGVuc2lvbnNfbWFwX2FsbBIcLmdvb2dsZS5w", + "cm90b2J1Zi5GaWxlT3B0aW9ucxix7AMgASgIOkAKGGdvcHJvdG9fdW5yZWNv", + "Z25pemVkX2FsbBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxiy7AMg", + "ASgIOjgKEGdvZ29wcm90b19pbXBvcnQSHC5nb29nbGUucHJvdG9idWYuRmls", + "ZU9wdGlvbnMYs+wDIAEoCDo2Cg5wcm90b3NpemVyX2FsbBIcLmdvb2dsZS5w", + "cm90b2J1Zi5GaWxlT3B0aW9ucxi07AMgASgIOjMKC2NvbXBhcmVfYWxsEhwu", + "Z29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGLXsAyABKAg6NAoMdHlwZWRl", + "Y2xfYWxsEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGLbsAyABKAg6", + "NAoMZW51bWRlY2xfYWxsEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25z", + "GLfsAyABKAg6PAoUZ29wcm90b19yZWdpc3RyYXRpb24SHC5nb29nbGUucHJv", + "dG9idWYuRmlsZU9wdGlvbnMYuOwDIAEoCDo3Cg9tZXNzYWdlbmFtZV9hbGwS", + "HC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMYuewDIAEoCDo9ChVnb3By", + "b3RvX3NpemVjYWNoZV9hbGwSHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlv", + "bnMYuuwDIAEoCDo7ChNnb3Byb3RvX3Vua2V5ZWRfYWxsEhwuZ29vZ2xlLnBy", + "b3RvYnVmLkZpbGVPcHRpb25zGLvsAyABKAg6OgoPZ29wcm90b19nZXR0ZXJz", + "Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGIH0AyABKAg6OwoQ", + "Z29wcm90b19zdHJpbmdlchIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0", + "aW9ucxiD9AMgASgIOjgKDXZlcmJvc2VfZXF1YWwSHy5nb29nbGUucHJvdG9i", + "dWYuTWVzc2FnZU9wdGlvbnMYhPQDIAEoCDovCgRmYWNlEh8uZ29vZ2xlLnBy", + "b3RvYnVmLk1lc3NhZ2VPcHRpb25zGIX0AyABKAg6MwoIZ29zdHJpbmcSHy5n", + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYhvQDIAEoCDozCghwb3B1", + "bGF0ZRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiH9AMgASgI", + "OjMKCHN0cmluZ2VyEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z", + "GMCLBCABKAg6MgoHb25seW9uZRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl", + "T3B0aW9ucxiJ9AMgASgIOjAKBWVxdWFsEh8uZ29vZ2xlLnByb3RvYnVmLk1l", + "c3NhZ2VPcHRpb25zGI30AyABKAg6NgoLZGVzY3JpcHRpb24SHy5nb29nbGUu", + "cHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYjvQDIAEoCDoyCgd0ZXN0Z2VuEh8u", + "Z29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGI/0AyABKAg6MwoIYmVu", + "Y2hnZW4SHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYkPQDIAEo", + "CDo0CgltYXJzaGFsZXISHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv", + "bnMYkfQDIAEoCDo2Cgt1bm1hcnNoYWxlchIfLmdvb2dsZS5wcm90b2J1Zi5N", + "ZXNzYWdlT3B0aW9ucxiS9AMgASgIOjsKEHN0YWJsZV9tYXJzaGFsZXISHy5n", + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYk/QDIAEoCDowCgVzaXpl", + "chIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiU9AMgASgIOjsK", + "EHVuc2FmZV9tYXJzaGFsZXISHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9w", + "dGlvbnMYl/QDIAEoCDo9ChJ1bnNhZmVfdW5tYXJzaGFsZXISHy5nb29nbGUu", + "cHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYmPQDIAEoCDpBChZnb3Byb3RvX2V4", + "dGVuc2lvbnNfbWFwEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z", + "GJn0AyABKAg6PwoUZ29wcm90b191bnJlY29nbml6ZWQSHy5nb29nbGUucHJv", + "dG9idWYuTWVzc2FnZU9wdGlvbnMYmvQDIAEoCDo1Cgpwcm90b3NpemVyEh8u", + "Z29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJz0AyABKAg6MgoHY29t", + "cGFyZRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxid9AMgASgI", + "OjMKCHR5cGVkZWNsEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z", + "GJ70AyABKAg6NgoLbWVzc2FnZW5hbWUSHy5nb29nbGUucHJvdG9idWYuTWVz", + "c2FnZU9wdGlvbnMYofQDIAEoCDo8ChFnb3Byb3RvX3NpemVjYWNoZRIfLmdv", + "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxii9AMgASgIOjoKD2dvcHJv", + "dG9fdW5rZXllZBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxij", + "9AMgASgIOjEKCG51bGxhYmxlEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0", + "aW9ucxjp+wMgASgIOi4KBWVtYmVkEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxk", + "T3B0aW9ucxjq+wMgASgIOjMKCmN1c3RvbXR5cGUSHS5nb29nbGUucHJvdG9i", + "dWYuRmllbGRPcHRpb25zGOv7AyABKAk6MwoKY3VzdG9tbmFtZRIdLmdvb2ds", + "ZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMY7PsDIAEoCTowCgdqc29udGFnEh0u", + "Z29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxjt+wMgASgJOjEKCG1vcmV0", + "YWdzEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxju+wMgASgJOjEK", + "CGNhc3R0eXBlEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxjv+wMg", + "ASgJOjAKB2Nhc3RrZXkSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25z", + "GPD7AyABKAk6MgoJY2FzdHZhbHVlEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxk", + "T3B0aW9ucxjx+wMgASgJOjAKB3N0ZHRpbWUSHS5nb29nbGUucHJvdG9idWYu", + "RmllbGRPcHRpb25zGPL7AyABKAg6NAoLc3RkZHVyYXRpb24SHS5nb29nbGUu", + "cHJvdG9idWYuRmllbGRPcHRpb25zGPP7AyABKAg6MwoKd2t0cG9pbnRlchId", + "Lmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMY9PsDIAEoCEJFChNjb20u", + "Z29vZ2xlLnByb3RvYnVmQgpHb0dvUHJvdG9zWiJnaXRodWIuY29tL2dvZ28v", + "cHJvdG9idWYvZ29nb3Byb3Rv")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.Reflection.DescriptorReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, new pb::Extension[] { GogoExtensions.GoprotoEnumPrefix, GogoExtensions.GoprotoEnumStringer, GogoExtensions.EnumStringer, GogoExtensions.EnumCustomname, GogoExtensions.Enumdecl, GogoExtensions.EnumvalueCustomname, GogoExtensions.GoprotoGettersAll, GogoExtensions.GoprotoEnumPrefixAll, GogoExtensions.GoprotoStringerAll, GogoExtensions.VerboseEqualAll, GogoExtensions.FaceAll, GogoExtensions.GostringAll, GogoExtensions.PopulateAll, GogoExtensions.StringerAll, GogoExtensions.OnlyoneAll, GogoExtensions.EqualAll, GogoExtensions.DescriptionAll, GogoExtensions.TestgenAll, GogoExtensions.BenchgenAll, GogoExtensions.MarshalerAll, GogoExtensions.UnmarshalerAll, GogoExtensions.StableMarshalerAll, GogoExtensions.SizerAll, GogoExtensions.GoprotoEnumStringerAll, GogoExtensions.EnumStringerAll, GogoExtensions.UnsafeMarshalerAll, GogoExtensions.UnsafeUnmarshalerAll, GogoExtensions.GoprotoExtensionsMapAll, GogoExtensions.GoprotoUnrecognizedAll, GogoExtensions.GogoprotoImport, GogoExtensions.ProtosizerAll, GogoExtensions.CompareAll, GogoExtensions.TypedeclAll, GogoExtensions.EnumdeclAll, GogoExtensions.GoprotoRegistration, GogoExtensions.MessagenameAll, GogoExtensions.GoprotoSizecacheAll, GogoExtensions.GoprotoUnkeyedAll, GogoExtensions.GoprotoGetters, GogoExtensions.GoprotoStringer, GogoExtensions.VerboseEqual, GogoExtensions.Face, GogoExtensions.Gostring, GogoExtensions.Populate, GogoExtensions.Stringer, GogoExtensions.Onlyone, GogoExtensions.Equal, GogoExtensions.Description, GogoExtensions.Testgen, GogoExtensions.Benchgen, GogoExtensions.Marshaler, GogoExtensions.Unmarshaler, GogoExtensions.StableMarshaler, GogoExtensions.Sizer, GogoExtensions.UnsafeMarshaler, GogoExtensions.UnsafeUnmarshaler, GogoExtensions.GoprotoExtensionsMap, GogoExtensions.GoprotoUnrecognized, GogoExtensions.Protosizer, GogoExtensions.Compare, GogoExtensions.Typedecl, GogoExtensions.Messagename, GogoExtensions.GoprotoSizecache, GogoExtensions.GoprotoUnkeyed, GogoExtensions.Nullable, GogoExtensions.Embed, GogoExtensions.Customtype, GogoExtensions.Customname, GogoExtensions.Jsontag, GogoExtensions.Moretags, GogoExtensions.Casttype, GogoExtensions.Castkey, GogoExtensions.Castvalue, GogoExtensions.Stdtime, GogoExtensions.Stdduration, GogoExtensions.Wktpointer }, null)); + } + #endregion + + } + /// Holder for extension identifiers generated from the top level of gogoproto/gogo.proto + internal static partial class GogoExtensions { + public static readonly pb::Extension GoprotoEnumPrefix = + new pb::Extension(62001, pb::FieldCodec.ForBool(496008, false)); + public static readonly pb::Extension GoprotoEnumStringer = + new pb::Extension(62021, pb::FieldCodec.ForBool(496168, false)); + public static readonly pb::Extension EnumStringer = + new pb::Extension(62022, pb::FieldCodec.ForBool(496176, false)); + public static readonly pb::Extension EnumCustomname = + new pb::Extension(62023, pb::FieldCodec.ForString(496186, "")); + public static readonly pb::Extension Enumdecl = + new pb::Extension(62024, pb::FieldCodec.ForBool(496192, false)); + public static readonly pb::Extension EnumvalueCustomname = + new pb::Extension(66001, pb::FieldCodec.ForString(528010, "")); + public static readonly pb::Extension GoprotoGettersAll = + new pb::Extension(63001, pb::FieldCodec.ForBool(504008, false)); + public static readonly pb::Extension GoprotoEnumPrefixAll = + new pb::Extension(63002, pb::FieldCodec.ForBool(504016, false)); + public static readonly pb::Extension GoprotoStringerAll = + new pb::Extension(63003, pb::FieldCodec.ForBool(504024, false)); + public static readonly pb::Extension VerboseEqualAll = + new pb::Extension(63004, pb::FieldCodec.ForBool(504032, false)); + public static readonly pb::Extension FaceAll = + new pb::Extension(63005, pb::FieldCodec.ForBool(504040, false)); + public static readonly pb::Extension GostringAll = + new pb::Extension(63006, pb::FieldCodec.ForBool(504048, false)); + public static readonly pb::Extension PopulateAll = + new pb::Extension(63007, pb::FieldCodec.ForBool(504056, false)); + public static readonly pb::Extension StringerAll = + new pb::Extension(63008, pb::FieldCodec.ForBool(504064, false)); + public static readonly pb::Extension OnlyoneAll = + new pb::Extension(63009, pb::FieldCodec.ForBool(504072, false)); + public static readonly pb::Extension EqualAll = + new pb::Extension(63013, pb::FieldCodec.ForBool(504104, false)); + public static readonly pb::Extension DescriptionAll = + new pb::Extension(63014, pb::FieldCodec.ForBool(504112, false)); + public static readonly pb::Extension TestgenAll = + new pb::Extension(63015, pb::FieldCodec.ForBool(504120, false)); + public static readonly pb::Extension BenchgenAll = + new pb::Extension(63016, pb::FieldCodec.ForBool(504128, false)); + public static readonly pb::Extension MarshalerAll = + new pb::Extension(63017, pb::FieldCodec.ForBool(504136, false)); + public static readonly pb::Extension UnmarshalerAll = + new pb::Extension(63018, pb::FieldCodec.ForBool(504144, false)); + public static readonly pb::Extension StableMarshalerAll = + new pb::Extension(63019, pb::FieldCodec.ForBool(504152, false)); + public static readonly pb::Extension SizerAll = + new pb::Extension(63020, pb::FieldCodec.ForBool(504160, false)); + public static readonly pb::Extension GoprotoEnumStringerAll = + new pb::Extension(63021, pb::FieldCodec.ForBool(504168, false)); + public static readonly pb::Extension EnumStringerAll = + new pb::Extension(63022, pb::FieldCodec.ForBool(504176, false)); + public static readonly pb::Extension UnsafeMarshalerAll = + new pb::Extension(63023, pb::FieldCodec.ForBool(504184, false)); + public static readonly pb::Extension UnsafeUnmarshalerAll = + new pb::Extension(63024, pb::FieldCodec.ForBool(504192, false)); + public static readonly pb::Extension GoprotoExtensionsMapAll = + new pb::Extension(63025, pb::FieldCodec.ForBool(504200, false)); + public static readonly pb::Extension GoprotoUnrecognizedAll = + new pb::Extension(63026, pb::FieldCodec.ForBool(504208, false)); + public static readonly pb::Extension GogoprotoImport = + new pb::Extension(63027, pb::FieldCodec.ForBool(504216, false)); + public static readonly pb::Extension ProtosizerAll = + new pb::Extension(63028, pb::FieldCodec.ForBool(504224, false)); + public static readonly pb::Extension CompareAll = + new pb::Extension(63029, pb::FieldCodec.ForBool(504232, false)); + public static readonly pb::Extension TypedeclAll = + new pb::Extension(63030, pb::FieldCodec.ForBool(504240, false)); + public static readonly pb::Extension EnumdeclAll = + new pb::Extension(63031, pb::FieldCodec.ForBool(504248, false)); + public static readonly pb::Extension GoprotoRegistration = + new pb::Extension(63032, pb::FieldCodec.ForBool(504256, false)); + public static readonly pb::Extension MessagenameAll = + new pb::Extension(63033, pb::FieldCodec.ForBool(504264, false)); + public static readonly pb::Extension GoprotoSizecacheAll = + new pb::Extension(63034, pb::FieldCodec.ForBool(504272, false)); + public static readonly pb::Extension GoprotoUnkeyedAll = + new pb::Extension(63035, pb::FieldCodec.ForBool(504280, false)); + public static readonly pb::Extension GoprotoGetters = + new pb::Extension(64001, pb::FieldCodec.ForBool(512008, false)); + public static readonly pb::Extension GoprotoStringer = + new pb::Extension(64003, pb::FieldCodec.ForBool(512024, false)); + public static readonly pb::Extension VerboseEqual = + new pb::Extension(64004, pb::FieldCodec.ForBool(512032, false)); + public static readonly pb::Extension Face = + new pb::Extension(64005, pb::FieldCodec.ForBool(512040, false)); + public static readonly pb::Extension Gostring = + new pb::Extension(64006, pb::FieldCodec.ForBool(512048, false)); + public static readonly pb::Extension Populate = + new pb::Extension(64007, pb::FieldCodec.ForBool(512056, false)); + public static readonly pb::Extension Stringer = + new pb::Extension(67008, pb::FieldCodec.ForBool(536064, false)); + public static readonly pb::Extension Onlyone = + new pb::Extension(64009, pb::FieldCodec.ForBool(512072, false)); + public static readonly pb::Extension Equal = + new pb::Extension(64013, pb::FieldCodec.ForBool(512104, false)); + public static readonly pb::Extension Description = + new pb::Extension(64014, pb::FieldCodec.ForBool(512112, false)); + public static readonly pb::Extension Testgen = + new pb::Extension(64015, pb::FieldCodec.ForBool(512120, false)); + public static readonly pb::Extension Benchgen = + new pb::Extension(64016, pb::FieldCodec.ForBool(512128, false)); + public static readonly pb::Extension Marshaler = + new pb::Extension(64017, pb::FieldCodec.ForBool(512136, false)); + public static readonly pb::Extension Unmarshaler = + new pb::Extension(64018, pb::FieldCodec.ForBool(512144, false)); + public static readonly pb::Extension StableMarshaler = + new pb::Extension(64019, pb::FieldCodec.ForBool(512152, false)); + public static readonly pb::Extension Sizer = + new pb::Extension(64020, pb::FieldCodec.ForBool(512160, false)); + public static readonly pb::Extension UnsafeMarshaler = + new pb::Extension(64023, pb::FieldCodec.ForBool(512184, false)); + public static readonly pb::Extension UnsafeUnmarshaler = + new pb::Extension(64024, pb::FieldCodec.ForBool(512192, false)); + public static readonly pb::Extension GoprotoExtensionsMap = + new pb::Extension(64025, pb::FieldCodec.ForBool(512200, false)); + public static readonly pb::Extension GoprotoUnrecognized = + new pb::Extension(64026, pb::FieldCodec.ForBool(512208, false)); + public static readonly pb::Extension Protosizer = + new pb::Extension(64028, pb::FieldCodec.ForBool(512224, false)); + public static readonly pb::Extension Compare = + new pb::Extension(64029, pb::FieldCodec.ForBool(512232, false)); + public static readonly pb::Extension Typedecl = + new pb::Extension(64030, pb::FieldCodec.ForBool(512240, false)); + public static readonly pb::Extension Messagename = + new pb::Extension(64033, pb::FieldCodec.ForBool(512264, false)); + public static readonly pb::Extension GoprotoSizecache = + new pb::Extension(64034, pb::FieldCodec.ForBool(512272, false)); + public static readonly pb::Extension GoprotoUnkeyed = + new pb::Extension(64035, pb::FieldCodec.ForBool(512280, false)); + public static readonly pb::Extension Nullable = + new pb::Extension(65001, pb::FieldCodec.ForBool(520008, false)); + public static readonly pb::Extension Embed = + new pb::Extension(65002, pb::FieldCodec.ForBool(520016, false)); + public static readonly pb::Extension Customtype = + new pb::Extension(65003, pb::FieldCodec.ForString(520026, "")); + public static readonly pb::Extension Customname = + new pb::Extension(65004, pb::FieldCodec.ForString(520034, "")); + public static readonly pb::Extension Jsontag = + new pb::Extension(65005, pb::FieldCodec.ForString(520042, "")); + public static readonly pb::Extension Moretags = + new pb::Extension(65006, pb::FieldCodec.ForString(520050, "")); + public static readonly pb::Extension Casttype = + new pb::Extension(65007, pb::FieldCodec.ForString(520058, "")); + public static readonly pb::Extension Castkey = + new pb::Extension(65008, pb::FieldCodec.ForString(520066, "")); + public static readonly pb::Extension Castvalue = + new pb::Extension(65009, pb::FieldCodec.ForString(520074, "")); + public static readonly pb::Extension Stdtime = + new pb::Extension(65010, pb::FieldCodec.ForBool(520080, false)); + public static readonly pb::Extension Stdduration = + new pb::Extension(65011, pb::FieldCodec.ForBool(520088, false)); + public static readonly pb::Extension Wktpointer = + new pb::Extension(65012, pb::FieldCodec.ForBool(520096, false)); + } + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Google/Api/Annotations.cs b/src/Communication/Jaeger.Communication.Grpc/Google/Api/Annotations.cs new file mode 100644 index 000000000..671a73b49 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Google/Api/Annotations.cs @@ -0,0 +1,52 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/api/annotations.proto +// +#pragma warning disable 1591, 0612, 3021 +#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.Api { + + /// Holder for reflection information generated from google/api/annotations.proto + internal static partial class AnnotationsReflection { + + #region Descriptor + /// File descriptor for google/api/annotations.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static AnnotationsReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Chxnb29nbGUvYXBpL2Fubm90YXRpb25zLnByb3RvEgpnb29nbGUuYXBpGhVn", + "b29nbGUvYXBpL2h0dHAucHJvdG8aIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlw", + "dG9yLnByb3RvOkUKBGh0dHASHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0", + "aW9ucxiwyrwiIAEoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGVCbgoOY29tLmdv", + "b2dsZS5hcGlCEEFubm90YXRpb25zUHJvdG9QAVpBZ29vZ2xlLmdvbGFuZy5v", + "cmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy9hcGkvYW5ub3RhdGlvbnM7YW5ub3Rh", + "dGlvbnOiAgRHQVBJYgZwcm90bzM=")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Api.HttpReflection.Descriptor, global::Google.Protobuf.Reflection.DescriptorReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, new pb::Extension[] { AnnotationsExtensions.Http }, null)); + } + #endregion + + } + /// Holder for extension identifiers generated from the top level of google/api/annotations.proto + internal static partial class AnnotationsExtensions { + /// + /// See `HttpRule`. + /// + public static readonly pb::Extension Http = + new pb::Extension(72295728, pb::FieldCodec.ForMessage(578365826, global::Google.Api.HttpRule.Parser)); + } + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Google/Api/Http.cs b/src/Communication/Jaeger.Communication.Grpc/Google/Api/Http.cs new file mode 100644 index 000000000..6b7beceb3 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Google/Api/Http.cs @@ -0,0 +1,1067 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/api/http.proto +// +#pragma warning disable 1591, 0612, 3021 +#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.Api { + + /// Holder for reflection information generated from google/api/http.proto + internal static partial class HttpReflection { + + #region Descriptor + /// File descriptor for google/api/http.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static HttpReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChVnb29nbGUvYXBpL2h0dHAucHJvdG8SCmdvb2dsZS5hcGkiVAoESHR0cBIj", + "CgVydWxlcxgBIAMoCzIULmdvb2dsZS5hcGkuSHR0cFJ1bGUSJwofZnVsbHlf", + "ZGVjb2RlX3Jlc2VydmVkX2V4cGFuc2lvbhgCIAEoCCKBAgoISHR0cFJ1bGUS", + "EAoIc2VsZWN0b3IYASABKAkSDQoDZ2V0GAIgASgJSAASDQoDcHV0GAMgASgJ", + "SAASDgoEcG9zdBgEIAEoCUgAEhAKBmRlbGV0ZRgFIAEoCUgAEg8KBXBhdGNo", + "GAYgASgJSAASLwoGY3VzdG9tGAggASgLMh0uZ29vZ2xlLmFwaS5DdXN0b21I", + "dHRwUGF0dGVybkgAEgwKBGJvZHkYByABKAkSFQoNcmVzcG9uc2VfYm9keRgM", + "IAEoCRIxChNhZGRpdGlvbmFsX2JpbmRpbmdzGAsgAygLMhQuZ29vZ2xlLmFw", + "aS5IdHRwUnVsZUIJCgdwYXR0ZXJuIi8KEUN1c3RvbUh0dHBQYXR0ZXJuEgwK", + "BGtpbmQYASABKAkSDAoEcGF0aBgCIAEoCUJqCg5jb20uZ29vZ2xlLmFwaUIJ", + "SHR0cFByb3RvUAFaQWdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2ds", + "ZWFwaXMvYXBpL2Fubm90YXRpb25zO2Fubm90YXRpb25z+AEBogIER0FQSWIG", + "cHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Api.Http), global::Google.Api.Http.Parser, new[]{ "Rules", "FullyDecodeReservedExpansion" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Api.HttpRule), global::Google.Api.HttpRule.Parser, new[]{ "Selector", "Get", "Put", "Post", "Delete", "Patch", "Custom", "Body", "ResponseBody", "AdditionalBindings" }, new[]{ "Pattern" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Google.Api.CustomHttpPattern), global::Google.Api.CustomHttpPattern.Parser, new[]{ "Kind", "Path" }, null, null, null, null) + })); + } + #endregion + + } + #region Messages + /// + /// Defines the HTTP configuration for an API service. It contains a list of + /// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method + /// to one or more HTTP REST API methods. + /// + internal sealed partial class Http : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Http()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Api.HttpReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Http() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Http(Http other) : this() { + rules_ = other.rules_.Clone(); + fullyDecodeReservedExpansion_ = other.fullyDecodeReservedExpansion_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Http Clone() { + return new Http(this); + } + + /// Field number for the "rules" field. + public const int RulesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_rules_codec + = pb::FieldCodec.ForMessage(10, global::Google.Api.HttpRule.Parser); + private readonly pbc::RepeatedField rules_ = new pbc::RepeatedField(); + /// + /// A list of HTTP configuration rules that apply to individual API methods. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Rules { + get { return rules_; } + } + + /// Field number for the "fully_decode_reserved_expansion" field. + public const int FullyDecodeReservedExpansionFieldNumber = 2; + private bool fullyDecodeReservedExpansion_; + /// + /// When set to true, URL path parmeters will be fully URI-decoded except in + /// cases of single segment matches in reserved expansion, where "%2F" will be + /// left encoded. + /// + /// The default behavior is to not decode RFC 6570 reserved characters in multi + /// segment matches. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool FullyDecodeReservedExpansion { + get { return fullyDecodeReservedExpansion_; } + set { + fullyDecodeReservedExpansion_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Http); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Http other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!rules_.Equals(other.rules_)) return false; + if (FullyDecodeReservedExpansion != other.FullyDecodeReservedExpansion) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= rules_.GetHashCode(); + if (FullyDecodeReservedExpansion != false) hash ^= FullyDecodeReservedExpansion.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + rules_.WriteTo(output, _repeated_rules_codec); + if (FullyDecodeReservedExpansion != false) { + output.WriteRawTag(16); + output.WriteBool(FullyDecodeReservedExpansion); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += rules_.CalculateSize(_repeated_rules_codec); + if (FullyDecodeReservedExpansion != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Http other) { + if (other == null) { + return; + } + rules_.Add(other.rules_); + if (other.FullyDecodeReservedExpansion != false) { + FullyDecodeReservedExpansion = other.FullyDecodeReservedExpansion; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + rules_.AddEntriesFrom(input, _repeated_rules_codec); + break; + } + case 16: { + FullyDecodeReservedExpansion = input.ReadBool(); + break; + } + } + } + } + + } + + /// + /// `HttpRule` defines the mapping of an RPC method to one or more HTTP + /// REST API methods. The mapping specifies how different portions of the RPC + /// request message are mapped to URL path, URL query parameters, and + /// HTTP request body. The mapping is typically specified as an + /// `google.api.http` annotation on the RPC method, + /// see "google/api/annotations.proto" for details. + /// + /// The mapping consists of a field specifying the path template and + /// method kind. The path template can refer to fields in the request + /// message, as in the example below which describes a REST GET + /// operation on a resource collection of messages: + /// + /// service Messaging { + /// rpc GetMessage(GetMessageRequest) returns (Message) { + /// option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}"; + /// } + /// } + /// message GetMessageRequest { + /// message SubMessage { + /// string subfield = 1; + /// } + /// string message_id = 1; // mapped to the URL + /// SubMessage sub = 2; // `sub.subfield` is url-mapped + /// } + /// message Message { + /// string text = 1; // content of the resource + /// } + /// + /// The same http annotation can alternatively be expressed inside the + /// `GRPC API Configuration` YAML file. + /// + /// http: + /// rules: + /// - selector: <proto_package_name>.Messaging.GetMessage + /// get: /v1/messages/{message_id}/{sub.subfield} + /// + /// This definition enables an automatic, bidrectional mapping of HTTP + /// JSON to RPC. Example: + /// + /// HTTP | RPC + /// -----|----- + /// `GET /v1/messages/123456/foo` | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))` + /// + /// In general, not only fields but also field paths can be referenced + /// from a path pattern. Fields mapped to the path pattern cannot be + /// repeated and must have a primitive (non-message) type. + /// + /// Any fields in the request message which are not bound by the path + /// pattern automatically become (optional) HTTP query + /// parameters. Assume the following definition of the request message: + /// + /// service Messaging { + /// rpc GetMessage(GetMessageRequest) returns (Message) { + /// option (google.api.http).get = "/v1/messages/{message_id}"; + /// } + /// } + /// message GetMessageRequest { + /// message SubMessage { + /// string subfield = 1; + /// } + /// string message_id = 1; // mapped to the URL + /// int64 revision = 2; // becomes a parameter + /// SubMessage sub = 3; // `sub.subfield` becomes a parameter + /// } + /// + /// This enables a HTTP JSON to RPC mapping as below: + /// + /// HTTP | RPC + /// -----|----- + /// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))` + /// + /// Note that fields which are mapped to HTTP parameters must have a + /// primitive type or a repeated primitive type. Message types are not + /// allowed. In the case of a repeated type, the parameter can be + /// repeated in the URL, as in `...?param=A&param=B`. + /// + /// For HTTP method kinds which allow a request body, the `body` field + /// specifies the mapping. Consider a REST update method on the + /// message resource collection: + /// + /// service Messaging { + /// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { + /// option (google.api.http) = { + /// put: "/v1/messages/{message_id}" + /// body: "message" + /// }; + /// } + /// } + /// message UpdateMessageRequest { + /// string message_id = 1; // mapped to the URL + /// Message message = 2; // mapped to the body + /// } + /// + /// The following HTTP JSON to RPC mapping is enabled, where the + /// representation of the JSON in the request body is determined by + /// protos JSON encoding: + /// + /// HTTP | RPC + /// -----|----- + /// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })` + /// + /// The special name `*` can be used in the body mapping to define that + /// every field not bound by the path template should be mapped to the + /// request body. This enables the following alternative definition of + /// the update method: + /// + /// service Messaging { + /// rpc UpdateMessage(Message) returns (Message) { + /// option (google.api.http) = { + /// put: "/v1/messages/{message_id}" + /// body: "*" + /// }; + /// } + /// } + /// message Message { + /// string message_id = 1; + /// string text = 2; + /// } + /// + /// The following HTTP JSON to RPC mapping is enabled: + /// + /// HTTP | RPC + /// -----|----- + /// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")` + /// + /// Note that when using `*` in the body mapping, it is not possible to + /// have HTTP parameters, as all fields not bound by the path end in + /// the body. This makes this option more rarely used in practice of + /// defining REST APIs. The common usage of `*` is in custom methods + /// which don't use the URL at all for transferring data. + /// + /// It is possible to define multiple HTTP methods for one RPC by using + /// the `additional_bindings` option. Example: + /// + /// service Messaging { + /// rpc GetMessage(GetMessageRequest) returns (Message) { + /// option (google.api.http) = { + /// get: "/v1/messages/{message_id}" + /// additional_bindings { + /// get: "/v1/users/{user_id}/messages/{message_id}" + /// } + /// }; + /// } + /// } + /// message GetMessageRequest { + /// string message_id = 1; + /// string user_id = 2; + /// } + /// + /// This enables the following two alternative HTTP JSON to RPC + /// mappings: + /// + /// HTTP | RPC + /// -----|----- + /// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` + /// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")` + /// + /// # Rules for HTTP mapping + /// + /// The rules for mapping HTTP path, query parameters, and body fields + /// to the request message are as follows: + /// + /// 1. The `body` field specifies either `*` or a field path, or is + /// omitted. If omitted, it indicates there is no HTTP request body. + /// 2. Leaf fields (recursive expansion of nested messages in the + /// request) can be classified into three types: + /// (a) Matched in the URL template. + /// (b) Covered by body (if body is `*`, everything except (a) fields; + /// else everything under the body field) + /// (c) All other fields. + /// 3. URL query parameters found in the HTTP request are mapped to (c) fields. + /// 4. Any body sent with an HTTP request can contain only (b) fields. + /// + /// The syntax of the path template is as follows: + /// + /// Template = "/" Segments [ Verb ] ; + /// Segments = Segment { "/" Segment } ; + /// Segment = "*" | "**" | LITERAL | Variable ; + /// Variable = "{" FieldPath [ "=" Segments ] "}" ; + /// FieldPath = IDENT { "." IDENT } ; + /// Verb = ":" LITERAL ; + /// + /// The syntax `*` matches a single path segment. The syntax `**` matches zero + /// or more path segments, which must be the last part of the path except the + /// `Verb`. The syntax `LITERAL` matches literal text in the path. + /// + /// The syntax `Variable` matches part of the URL path as specified by its + /// template. A variable template must not contain other variables. If a variable + /// matches a single path segment, its template may be omitted, e.g. `{var}` + /// is equivalent to `{var=*}`. + /// + /// If a variable contains exactly one path segment, such as `"{var}"` or + /// `"{var=*}"`, when such a variable is expanded into a URL path, all characters + /// except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up in the + /// Discovery Document as `{var}`. + /// + /// If a variable contains one or more path segments, such as `"{var=foo/*}"` + /// or `"{var=**}"`, when such a variable is expanded into a URL path, all + /// characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such variables + /// show up in the Discovery Document as `{+var}`. + /// + /// NOTE: While the single segment variable matches the semantics of + /// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 + /// Simple String Expansion, the multi segment variable **does not** match + /// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion + /// does not expand special characters like `?` and `#`, which would lead + /// to invalid URLs. + /// + /// NOTE: the field paths in variables and in the `body` must not refer to + /// repeated fields or map fields. + /// + internal sealed partial class HttpRule : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new HttpRule()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Api.HttpReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public HttpRule() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public HttpRule(HttpRule other) : this() { + selector_ = other.selector_; + body_ = other.body_; + responseBody_ = other.responseBody_; + additionalBindings_ = other.additionalBindings_.Clone(); + switch (other.PatternCase) { + case PatternOneofCase.Get: + Get = other.Get; + break; + case PatternOneofCase.Put: + Put = other.Put; + break; + case PatternOneofCase.Post: + Post = other.Post; + break; + case PatternOneofCase.Delete: + Delete = other.Delete; + break; + case PatternOneofCase.Patch: + Patch = other.Patch; + break; + case PatternOneofCase.Custom: + Custom = other.Custom.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public HttpRule Clone() { + return new HttpRule(this); + } + + /// Field number for the "selector" field. + public const int SelectorFieldNumber = 1; + private string selector_ = ""; + /// + /// Selects methods to which this rule applies. + /// + /// Refer to [selector][google.api.DocumentationRule.selector] for syntax details. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Selector { + get { return selector_; } + set { + selector_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "get" field. + public const int GetFieldNumber = 2; + /// + /// Used for listing and getting information about resources. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Get { + get { return patternCase_ == PatternOneofCase.Get ? (string) pattern_ : ""; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + patternCase_ = PatternOneofCase.Get; + } + } + + /// Field number for the "put" field. + public const int PutFieldNumber = 3; + /// + /// Used for updating a resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Put { + get { return patternCase_ == PatternOneofCase.Put ? (string) pattern_ : ""; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + patternCase_ = PatternOneofCase.Put; + } + } + + /// Field number for the "post" field. + public const int PostFieldNumber = 4; + /// + /// Used for creating a resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Post { + get { return patternCase_ == PatternOneofCase.Post ? (string) pattern_ : ""; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + patternCase_ = PatternOneofCase.Post; + } + } + + /// Field number for the "delete" field. + public const int DeleteFieldNumber = 5; + /// + /// Used for deleting a resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Delete { + get { return patternCase_ == PatternOneofCase.Delete ? (string) pattern_ : ""; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + patternCase_ = PatternOneofCase.Delete; + } + } + + /// Field number for the "patch" field. + public const int PatchFieldNumber = 6; + /// + /// Used for updating a resource. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Patch { + get { return patternCase_ == PatternOneofCase.Patch ? (string) pattern_ : ""; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + patternCase_ = PatternOneofCase.Patch; + } + } + + /// Field number for the "custom" field. + public const int CustomFieldNumber = 8; + /// + /// The custom pattern is used for specifying an HTTP method that is not + /// included in the `pattern` field, such as HEAD, or "*" to leave the + /// HTTP method unspecified for this rule. The wild-card rule is useful + /// for services that provide content to Web (HTML) clients. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Api.CustomHttpPattern Custom { + get { return patternCase_ == PatternOneofCase.Custom ? (global::Google.Api.CustomHttpPattern) pattern_ : null; } + set { + pattern_ = value; + patternCase_ = value == null ? PatternOneofCase.None : PatternOneofCase.Custom; + } + } + + /// Field number for the "body" field. + public const int BodyFieldNumber = 7; + private string body_ = ""; + /// + /// The name of the request field whose value is mapped to the HTTP body, or + /// `*` for mapping all fields not captured by the path pattern to the HTTP + /// body. NOTE: the referred field must not be a repeated field and must be + /// present at the top-level of request message type. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Body { + get { return body_; } + set { + body_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "response_body" field. + public const int ResponseBodyFieldNumber = 12; + private string responseBody_ = ""; + /// + /// Optional. The name of the response field whose value is mapped to the HTTP + /// body of response. Other response fields are ignored. When + /// not set, the response message will be used as HTTP body of response. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ResponseBody { + get { return responseBody_; } + set { + responseBody_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "additional_bindings" field. + public const int AdditionalBindingsFieldNumber = 11; + private static readonly pb::FieldCodec _repeated_additionalBindings_codec + = pb::FieldCodec.ForMessage(90, global::Google.Api.HttpRule.Parser); + private readonly pbc::RepeatedField additionalBindings_ = new pbc::RepeatedField(); + /// + /// Additional HTTP bindings for the selector. Nested bindings must + /// not contain an `additional_bindings` field themselves (that is, + /// the nesting may only be one level deep). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField AdditionalBindings { + get { return additionalBindings_; } + } + + private object pattern_; + /// Enum of possible cases for the "pattern" oneof. + public enum PatternOneofCase { + None = 0, + Get = 2, + Put = 3, + Post = 4, + Delete = 5, + Patch = 6, + Custom = 8, + } + private PatternOneofCase patternCase_ = PatternOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PatternOneofCase PatternCase { + get { return patternCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void ClearPattern() { + patternCase_ = PatternOneofCase.None; + pattern_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as HttpRule); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(HttpRule other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Selector != other.Selector) return false; + if (Get != other.Get) return false; + if (Put != other.Put) return false; + if (Post != other.Post) return false; + if (Delete != other.Delete) return false; + if (Patch != other.Patch) return false; + if (!object.Equals(Custom, other.Custom)) return false; + if (Body != other.Body) return false; + if (ResponseBody != other.ResponseBody) return false; + if(!additionalBindings_.Equals(other.additionalBindings_)) return false; + if (PatternCase != other.PatternCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Selector.Length != 0) hash ^= Selector.GetHashCode(); + if (patternCase_ == PatternOneofCase.Get) hash ^= Get.GetHashCode(); + if (patternCase_ == PatternOneofCase.Put) hash ^= Put.GetHashCode(); + if (patternCase_ == PatternOneofCase.Post) hash ^= Post.GetHashCode(); + if (patternCase_ == PatternOneofCase.Delete) hash ^= Delete.GetHashCode(); + if (patternCase_ == PatternOneofCase.Patch) hash ^= Patch.GetHashCode(); + if (patternCase_ == PatternOneofCase.Custom) hash ^= Custom.GetHashCode(); + if (Body.Length != 0) hash ^= Body.GetHashCode(); + if (ResponseBody.Length != 0) hash ^= ResponseBody.GetHashCode(); + hash ^= additionalBindings_.GetHashCode(); + hash ^= (int) patternCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Selector.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Selector); + } + if (patternCase_ == PatternOneofCase.Get) { + output.WriteRawTag(18); + output.WriteString(Get); + } + if (patternCase_ == PatternOneofCase.Put) { + output.WriteRawTag(26); + output.WriteString(Put); + } + if (patternCase_ == PatternOneofCase.Post) { + output.WriteRawTag(34); + output.WriteString(Post); + } + if (patternCase_ == PatternOneofCase.Delete) { + output.WriteRawTag(42); + output.WriteString(Delete); + } + if (patternCase_ == PatternOneofCase.Patch) { + output.WriteRawTag(50); + output.WriteString(Patch); + } + if (Body.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Body); + } + if (patternCase_ == PatternOneofCase.Custom) { + output.WriteRawTag(66); + output.WriteMessage(Custom); + } + additionalBindings_.WriteTo(output, _repeated_additionalBindings_codec); + if (ResponseBody.Length != 0) { + output.WriteRawTag(98); + output.WriteString(ResponseBody); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Selector.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Selector); + } + if (patternCase_ == PatternOneofCase.Get) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Get); + } + if (patternCase_ == PatternOneofCase.Put) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Put); + } + if (patternCase_ == PatternOneofCase.Post) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Post); + } + if (patternCase_ == PatternOneofCase.Delete) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Delete); + } + if (patternCase_ == PatternOneofCase.Patch) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Patch); + } + if (patternCase_ == PatternOneofCase.Custom) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Custom); + } + if (Body.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Body); + } + if (ResponseBody.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ResponseBody); + } + size += additionalBindings_.CalculateSize(_repeated_additionalBindings_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(HttpRule other) { + if (other == null) { + return; + } + if (other.Selector.Length != 0) { + Selector = other.Selector; + } + if (other.Body.Length != 0) { + Body = other.Body; + } + if (other.ResponseBody.Length != 0) { + ResponseBody = other.ResponseBody; + } + additionalBindings_.Add(other.additionalBindings_); + switch (other.PatternCase) { + case PatternOneofCase.Get: + Get = other.Get; + break; + case PatternOneofCase.Put: + Put = other.Put; + break; + case PatternOneofCase.Post: + Post = other.Post; + break; + case PatternOneofCase.Delete: + Delete = other.Delete; + break; + case PatternOneofCase.Patch: + Patch = other.Patch; + break; + case PatternOneofCase.Custom: + if (Custom == null) { + Custom = new global::Google.Api.CustomHttpPattern(); + } + Custom.MergeFrom(other.Custom); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Selector = input.ReadString(); + break; + } + case 18: { + Get = input.ReadString(); + break; + } + case 26: { + Put = input.ReadString(); + break; + } + case 34: { + Post = input.ReadString(); + break; + } + case 42: { + Delete = input.ReadString(); + break; + } + case 50: { + Patch = input.ReadString(); + break; + } + case 58: { + Body = input.ReadString(); + break; + } + case 66: { + global::Google.Api.CustomHttpPattern subBuilder = new global::Google.Api.CustomHttpPattern(); + if (patternCase_ == PatternOneofCase.Custom) { + subBuilder.MergeFrom(Custom); + } + input.ReadMessage(subBuilder); + Custom = subBuilder; + break; + } + case 90: { + additionalBindings_.AddEntriesFrom(input, _repeated_additionalBindings_codec); + break; + } + case 98: { + ResponseBody = input.ReadString(); + break; + } + } + } + } + + } + + /// + /// A custom pattern is used for defining custom HTTP verb. + /// + internal sealed partial class CustomHttpPattern : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CustomHttpPattern()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Google.Api.HttpReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CustomHttpPattern() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CustomHttpPattern(CustomHttpPattern other) : this() { + kind_ = other.kind_; + path_ = other.path_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public CustomHttpPattern Clone() { + return new CustomHttpPattern(this); + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 1; + private string kind_ = ""; + /// + /// The name of this custom HTTP verb. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Kind { + get { return kind_; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "path" field. + public const int PathFieldNumber = 2; + private string path_ = ""; + /// + /// The path matched by this custom verb. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Path { + get { return path_; } + set { + path_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as CustomHttpPattern); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(CustomHttpPattern other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Kind != other.Kind) return false; + if (Path != other.Path) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Kind.Length != 0) hash ^= Kind.GetHashCode(); + if (Path.Length != 0) hash ^= Path.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Kind.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Kind); + } + if (Path.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Path); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Kind.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Kind); + } + if (Path.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Path); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(CustomHttpPattern other) { + if (other == null) { + return; + } + if (other.Kind.Length != 0) { + Kind = other.Kind; + } + if (other.Path.Length != 0) { + Path = other.Path; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Kind = input.ReadString(); + break; + } + case 18: { + Path = input.ReadString(); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Annotations.cs b/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Annotations.cs new file mode 100644 index 000000000..0b2b57864 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Annotations.cs @@ -0,0 +1,98 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: protoc-gen-swagger/options/annotations.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Grpc.Gateway.ProtocGenSwagger.Options { + + /// Holder for reflection information generated from protoc-gen-swagger/options/annotations.proto + internal static partial class AnnotationsReflection { + + #region Descriptor + /// File descriptor for protoc-gen-swagger/options/annotations.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static AnnotationsReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cixwcm90b2MtZ2VuLXN3YWdnZXIvb3B0aW9ucy9hbm5vdGF0aW9ucy5wcm90", + "bxInZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zGiBn", + "b29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxoqcHJvdG9jLWdlbi1z", + "d2FnZ2VyL29wdGlvbnMvb3BlbmFwaXYyLnByb3RvOmoKEW9wZW5hcGl2Ml9z", + "d2FnZ2VyEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGJIIIAEoCzIw", + "LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5Td2Fn", + "Z2VyOnAKE29wZW5hcGl2Ml9vcGVyYXRpb24SHi5nb29nbGUucHJvdG9idWYu", + "TWV0aG9kT3B0aW9ucxiSCCABKAsyMi5ncnBjLmdhdGV3YXkucHJvdG9jX2dl", + "bl9zd2FnZ2VyLm9wdGlvbnMuT3BlcmF0aW9uOmsKEG9wZW5hcGl2Ml9zY2hl", + "bWESHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYkgggASgLMi8u", + "Z3JwYy5nYXRld2F5LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLlNjaGVt", + "YTplCg1vcGVuYXBpdjJfdGFnEh8uZ29vZ2xlLnByb3RvYnVmLlNlcnZpY2VP", + "cHRpb25zGJIIIAEoCzIsLmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdn", + "ZXIub3B0aW9ucy5UYWc6bAoPb3BlbmFwaXYyX2ZpZWxkEh0uZ29vZ2xlLnBy", + "b3RvYnVmLkZpZWxkT3B0aW9ucxiSCCABKAsyMy5ncnBjLmdhdGV3YXkucHJv", + "dG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuSlNPTlNjaGVtYUJDWkFnaXRodWIu", + "Y29tL2dycGMtZWNvc3lzdGVtL2dycGMtZ2F0ZXdheS9wcm90b2MtZ2VuLXN3", + "YWdnZXIvb3B0aW9uc2IGcHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.Reflection.DescriptorReflection.Descriptor, global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, new pb::Extension[] { AnnotationsExtensions.Openapiv2Swagger, AnnotationsExtensions.Openapiv2Operation, AnnotationsExtensions.Openapiv2Schema, AnnotationsExtensions.Openapiv2Tag, AnnotationsExtensions.Openapiv2Field }, null)); + } + #endregion + + } + /// Holder for extension identifiers generated from the top level of protoc-gen-swagger/options/annotations.proto + internal static partial class AnnotationsExtensions { + /// + /// ID assigned by protobuf-global-extension-registry@google.com for grpc-gateway project. + /// + /// All IDs are the same, as assigned. It is okay that they are the same, as they extend + /// different descriptor messages. + /// + public static readonly pb::Extension Openapiv2Swagger = + new pb::Extension(1042, pb::FieldCodec.ForMessage(8338, global::Grpc.Gateway.ProtocGenSwagger.Options.Swagger.Parser)); + /// + /// ID assigned by protobuf-global-extension-registry@google.com for grpc-gateway project. + /// + /// All IDs are the same, as assigned. It is okay that they are the same, as they extend + /// different descriptor messages. + /// + public static readonly pb::Extension Openapiv2Operation = + new pb::Extension(1042, pb::FieldCodec.ForMessage(8338, global::Grpc.Gateway.ProtocGenSwagger.Options.Operation.Parser)); + /// + /// ID assigned by protobuf-global-extension-registry@google.com for grpc-gateway project. + /// + /// All IDs are the same, as assigned. It is okay that they are the same, as they extend + /// different descriptor messages. + /// + public static readonly pb::Extension Openapiv2Schema = + new pb::Extension(1042, pb::FieldCodec.ForMessage(8338, global::Grpc.Gateway.ProtocGenSwagger.Options.Schema.Parser)); + /// + /// ID assigned by protobuf-global-extension-registry@google.com for grpc-gateway project. + /// + /// All IDs are the same, as assigned. It is okay that they are the same, as they extend + /// different descriptor messages. + /// + public static readonly pb::Extension Openapiv2Tag = + new pb::Extension(1042, pb::FieldCodec.ForMessage(8338, global::Grpc.Gateway.ProtocGenSwagger.Options.Tag.Parser)); + /// + /// ID assigned by protobuf-global-extension-registry@google.com for grpc-gateway project. + /// + /// All IDs are the same, as assigned. It is okay that they are the same, as they extend + /// different descriptor messages. + /// + public static readonly pb::Extension Openapiv2Field = + new pb::Extension(1042, pb::FieldCodec.ForMessage(8338, global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema.Parser)); + } + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Openapiv2.cs b/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Openapiv2.cs new file mode 100644 index 000000000..9a2cec078 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Grpc/Gateway/ProtocGenSwagger/Options/Openapiv2.cs @@ -0,0 +1,4187 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: protoc-gen-swagger/options/openapiv2.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Grpc.Gateway.ProtocGenSwagger.Options { + + /// Holder for reflection information generated from protoc-gen-swagger/options/openapiv2.proto + internal static partial class Openapiv2Reflection { + + #region Descriptor + /// File descriptor for protoc-gen-swagger/options/openapiv2.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static Openapiv2Reflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cipwcm90b2MtZ2VuLXN3YWdnZXIvb3B0aW9ucy9vcGVuYXBpdjIucHJvdG8S", + "J2dycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucxoZZ29v", + "Z2xlL3Byb3RvYnVmL2FueS5wcm90bxocZ29vZ2xlL3Byb3RvYnVmL3N0cnVj", + "dC5wcm90byKgBwoHU3dhZ2dlchIPCgdzd2FnZ2VyGAEgASgJEjsKBGluZm8Y", + "AiABKAsyLS5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlv", + "bnMuSW5mbxIMCgRob3N0GAMgASgJEhEKCWJhc2VfcGF0aBgEIAEoCRJPCgdz", + "Y2hlbWVzGAUgAygOMj4uZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fc3dhZ2dl", + "ci5vcHRpb25zLlN3YWdnZXIuU3dhZ2dlclNjaGVtZRIQCghjb25zdW1lcxgG", + "IAMoCRIQCghwcm9kdWNlcxgHIAMoCRJSCglyZXNwb25zZXMYCiADKAsyPy5n", + "cnBjLmdhdGV3YXkucHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuU3dhZ2dl", + "ci5SZXNwb25zZXNFbnRyeRJaChRzZWN1cml0eV9kZWZpbml0aW9ucxgLIAEo", + "CzI8LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5T", + "ZWN1cml0eURlZmluaXRpb25zEk4KCHNlY3VyaXR5GAwgAygLMjwuZ3JwYy5n", + "YXRld2F5LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLlNlY3VyaXR5UmVx", + "dWlyZW1lbnQSVQoNZXh0ZXJuYWxfZG9jcxgOIAEoCzI+LmdycGMuZ2F0ZXdh", + "eS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5FeHRlcm5hbERvY3VtZW50", + "YXRpb24SVAoKZXh0ZW5zaW9ucxgPIAMoCzJALmdycGMuZ2F0ZXdheS5wcm90", + "b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5Td2FnZ2VyLkV4dGVuc2lvbnNFbnRy", + "eRpjCg5SZXNwb25zZXNFbnRyeRILCgNrZXkYASABKAkSQAoFdmFsdWUYAiAB", + "KAsyMS5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMu", + "UmVzcG9uc2U6AjgBGkkKD0V4dGVuc2lvbnNFbnRyeRILCgNrZXkYASABKAkS", + "JQoFdmFsdWUYAiABKAsyFi5nb29nbGUucHJvdG9idWYuVmFsdWU6AjgBIkIK", + "DVN3YWdnZXJTY2hlbWUSCwoHVU5LTk9XThAAEggKBEhUVFAQARIJCgVIVFRQ", + "UxACEgYKAldTEAMSBwoDV1NTEARKBAgIEAlKBAgJEApKBAgNEA4iqQUKCU9w", + "ZXJhdGlvbhIMCgR0YWdzGAEgAygJEg8KB3N1bW1hcnkYAiABKAkSEwoLZGVz", + "Y3JpcHRpb24YAyABKAkSVQoNZXh0ZXJuYWxfZG9jcxgEIAEoCzI+LmdycGMu", + "Z2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5FeHRlcm5hbERv", + "Y3VtZW50YXRpb24SFAoMb3BlcmF0aW9uX2lkGAUgASgJEhAKCGNvbnN1bWVz", + "GAYgAygJEhAKCHByb2R1Y2VzGAcgAygJElQKCXJlc3BvbnNlcxgJIAMoCzJB", + "LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5PcGVy", + "YXRpb24uUmVzcG9uc2VzRW50cnkSDwoHc2NoZW1lcxgKIAMoCRISCgpkZXBy", + "ZWNhdGVkGAsgASgIEk4KCHNlY3VyaXR5GAwgAygLMjwuZ3JwYy5nYXRld2F5", + "LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLlNlY3VyaXR5UmVxdWlyZW1l", + "bnQSVgoKZXh0ZW5zaW9ucxgNIAMoCzJCLmdycGMuZ2F0ZXdheS5wcm90b2Nf", + "Z2VuX3N3YWdnZXIub3B0aW9ucy5PcGVyYXRpb24uRXh0ZW5zaW9uc0VudHJ5", + "GmMKDlJlc3BvbnNlc0VudHJ5EgsKA2tleRgBIAEoCRJACgV2YWx1ZRgCIAEo", + "CzIxLmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5S", + "ZXNwb25zZToCOAEaSQoPRXh0ZW5zaW9uc0VudHJ5EgsKA2tleRgBIAEoCRIl", + "CgV2YWx1ZRgCIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZToCOAFKBAgI", + "EAkijAMKCFJlc3BvbnNlEhMKC2Rlc2NyaXB0aW9uGAEgASgJEj8KBnNjaGVt", + "YRgCIAEoCzIvLmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0", + "aW9ucy5TY2hlbWESUQoIZXhhbXBsZXMYBCADKAsyPy5ncnBjLmdhdGV3YXku", + "cHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuUmVzcG9uc2UuRXhhbXBsZXNF", + "bnRyeRJVCgpleHRlbnNpb25zGAUgAygLMkEuZ3JwYy5nYXRld2F5LnByb3Rv", + "Y19nZW5fc3dhZ2dlci5vcHRpb25zLlJlc3BvbnNlLkV4dGVuc2lvbnNFbnRy", + "eRovCg1FeGFtcGxlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEo", + "CToCOAEaSQoPRXh0ZW5zaW9uc0VudHJ5EgsKA2tleRgBIAEoCRIlCgV2YWx1", + "ZRgCIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZToCOAFKBAgDEAQi+QIK", + "BEluZm8SDQoFdGl0bGUYASABKAkSEwoLZGVzY3JpcHRpb24YAiABKAkSGAoQ", + "dGVybXNfb2Zfc2VydmljZRgDIAEoCRJBCgdjb250YWN0GAQgASgLMjAuZ3Jw", + "Yy5nYXRld2F5LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLkNvbnRhY3QS", + "QQoHbGljZW5zZRgFIAEoCzIwLmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3", + "YWdnZXIub3B0aW9ucy5MaWNlbnNlEg8KB3ZlcnNpb24YBiABKAkSUQoKZXh0", + "ZW5zaW9ucxgHIAMoCzI9LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdn", + "ZXIub3B0aW9ucy5JbmZvLkV4dGVuc2lvbnNFbnRyeRpJCg9FeHRlbnNpb25z", + "RW50cnkSCwoDa2V5GAEgASgJEiUKBXZhbHVlGAIgASgLMhYuZ29vZ2xlLnBy", + "b3RvYnVmLlZhbHVlOgI4ASIzCgdDb250YWN0EgwKBG5hbWUYASABKAkSCwoD", + "dXJsGAIgASgJEg0KBWVtYWlsGAMgASgJIiQKB0xpY2Vuc2USDAoEbmFtZRgB", + "IAEoCRILCgN1cmwYAiABKAkiOQoVRXh0ZXJuYWxEb2N1bWVudGF0aW9uEhMK", + "C2Rlc2NyaXB0aW9uGAEgASgJEgsKA3VybBgCIAEoCSKAAgoGU2NoZW1hEkgK", + "C2pzb25fc2NoZW1hGAEgASgLMjMuZ3JwYy5nYXRld2F5LnByb3RvY19nZW5f", + "c3dhZ2dlci5vcHRpb25zLkpTT05TY2hlbWESFQoNZGlzY3JpbWluYXRvchgC", + "IAEoCRIRCglyZWFkX29ubHkYAyABKAgSVQoNZXh0ZXJuYWxfZG9jcxgFIAEo", + "CzI+LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0aW9ucy5F", + "eHRlcm5hbERvY3VtZW50YXRpb24SJQoHZXhhbXBsZRgGIAEoCzIULmdvb2ds", + "ZS5wcm90b2J1Zi5BbnlKBAgEEAUiugUKCkpTT05TY2hlbWESCwoDcmVmGAMg", + "ASgJEg0KBXRpdGxlGAUgASgJEhMKC2Rlc2NyaXB0aW9uGAYgASgJEg8KB2Rl", + "ZmF1bHQYByABKAkSEQoJcmVhZF9vbmx5GAggASgIEhMKC211bHRpcGxlX29m", + "GAogASgBEg8KB21heGltdW0YCyABKAESGQoRZXhjbHVzaXZlX21heGltdW0Y", + "DCABKAgSDwoHbWluaW11bRgNIAEoARIZChFleGNsdXNpdmVfbWluaW11bRgO", + "IAEoCBISCgptYXhfbGVuZ3RoGA8gASgEEhIKCm1pbl9sZW5ndGgYECABKAQS", + "DwoHcGF0dGVybhgRIAEoCRIRCgltYXhfaXRlbXMYFCABKAQSEQoJbWluX2l0", + "ZW1zGBUgASgEEhQKDHVuaXF1ZV9pdGVtcxgWIAEoCBIWCg5tYXhfcHJvcGVy", + "dGllcxgYIAEoBBIWCg5taW5fcHJvcGVydGllcxgZIAEoBBIQCghyZXF1aXJl", + "ZBgaIAMoCRINCgVhcnJheRgiIAMoCRJXCgR0eXBlGCMgAygOMkkuZ3JwYy5n", + "YXRld2F5LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLkpTT05TY2hlbWEu", + "SlNPTlNjaGVtYVNpbXBsZVR5cGVzIncKFUpTT05TY2hlbWFTaW1wbGVUeXBl", + "cxILCgdVTktOT1dOEAASCQoFQVJSQVkQARILCgdCT09MRUFOEAISCwoHSU5U", + "RUdFUhADEggKBE5VTEwQBBIKCgZOVU1CRVIQBRIKCgZPQkpFQ1QQBhIKCgZT", + "VFJJTkcQB0oECAEQAkoECAIQA0oECAQQBUoECAkQCkoECBIQE0oECBMQFEoE", + "CBcQGEoECBsQHEoECBwQHUoECB0QHkoECB4QIkoECCQQKkoECCoQK0oECCsQ", + "LiJ3CgNUYWcSEwoLZGVzY3JpcHRpb24YAiABKAkSVQoNZXh0ZXJuYWxfZG9j", + "cxgDIAEoCzI+LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2VuX3N3YWdnZXIub3B0", + "aW9ucy5FeHRlcm5hbERvY3VtZW50YXRpb25KBAgBEAIi3QEKE1NlY3VyaXR5", + "RGVmaW5pdGlvbnMSXAoIc2VjdXJpdHkYASADKAsySi5ncnBjLmdhdGV3YXku", + "cHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuU2VjdXJpdHlEZWZpbml0aW9u", + "cy5TZWN1cml0eUVudHJ5GmgKDVNlY3VyaXR5RW50cnkSCwoDa2V5GAEgASgJ", + "EkYKBXZhbHVlGAIgASgLMjcuZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fc3dh", + "Z2dlci5vcHRpb25zLlNlY3VyaXR5U2NoZW1lOgI4ASKWBgoOU2VjdXJpdHlT", + "Y2hlbWUSSgoEdHlwZRgBIAEoDjI8LmdycGMuZ2F0ZXdheS5wcm90b2NfZ2Vu", + "X3N3YWdnZXIub3B0aW9ucy5TZWN1cml0eVNjaGVtZS5UeXBlEhMKC2Rlc2Ny", + "aXB0aW9uGAIgASgJEgwKBG5hbWUYAyABKAkSRgoCaW4YBCABKA4yOi5ncnBj", + "LmdhdGV3YXkucHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuU2VjdXJpdHlT", + "Y2hlbWUuSW4SSgoEZmxvdxgFIAEoDjI8LmdycGMuZ2F0ZXdheS5wcm90b2Nf", + "Z2VuX3N3YWdnZXIub3B0aW9ucy5TZWN1cml0eVNjaGVtZS5GbG93EhkKEWF1", + "dGhvcml6YXRpb25fdXJsGAYgASgJEhEKCXRva2VuX3VybBgHIAEoCRI/CgZz", + "Y29wZXMYCCABKAsyLy5ncnBjLmdhdGV3YXkucHJvdG9jX2dlbl9zd2FnZ2Vy", + "Lm9wdGlvbnMuU2NvcGVzElsKCmV4dGVuc2lvbnMYCSADKAsyRy5ncnBjLmdh", + "dGV3YXkucHJvdG9jX2dlbl9zd2FnZ2VyLm9wdGlvbnMuU2VjdXJpdHlTY2hl", + "bWUuRXh0ZW5zaW9uc0VudHJ5GkkKD0V4dGVuc2lvbnNFbnRyeRILCgNrZXkY", + "ASABKAkSJQoFdmFsdWUYAiABKAsyFi5nb29nbGUucHJvdG9idWYuVmFsdWU6", + "AjgBIksKBFR5cGUSEAoMVFlQRV9JTlZBTElEEAASDgoKVFlQRV9CQVNJQxAB", + "EhAKDFRZUEVfQVBJX0tFWRACEg8KC1RZUEVfT0FVVEgyEAMiMQoCSW4SDgoK", + "SU5fSU5WQUxJRBAAEgwKCElOX1FVRVJZEAESDQoJSU5fSEVBREVSEAIiagoE", + "RmxvdxIQCgxGTE9XX0lOVkFMSUQQABIRCg1GTE9XX0lNUExJQ0lUEAESEQoN", + "RkxPV19QQVNTV09SRBACEhQKEEZMT1dfQVBQTElDQVRJT04QAxIUChBGTE9X", + "X0FDQ0VTU19DT0RFEAQiyQIKE1NlY3VyaXR5UmVxdWlyZW1lbnQScwoUc2Vj", + "dXJpdHlfcmVxdWlyZW1lbnQYASADKAsyVS5ncnBjLmdhdGV3YXkucHJvdG9j", + "X2dlbl9zd2FnZ2VyLm9wdGlvbnMuU2VjdXJpdHlSZXF1aXJlbWVudC5TZWN1", + "cml0eVJlcXVpcmVtZW50RW50cnkaKQoYU2VjdXJpdHlSZXF1aXJlbWVudFZh", + "bHVlEg0KBXNjb3BlGAEgAygJGpEBChhTZWN1cml0eVJlcXVpcmVtZW50RW50", + "cnkSCwoDa2V5GAEgASgJEmQKBXZhbHVlGAIgASgLMlUuZ3JwYy5nYXRld2F5", + "LnByb3RvY19nZW5fc3dhZ2dlci5vcHRpb25zLlNlY3VyaXR5UmVxdWlyZW1l", + "bnQuU2VjdXJpdHlSZXF1aXJlbWVudFZhbHVlOgI4ASKBAQoGU2NvcGVzEkkK", + "BXNjb3BlGAEgAygLMjouZ3JwYy5nYXRld2F5LnByb3RvY19nZW5fc3dhZ2dl", + "ci5vcHRpb25zLlNjb3Blcy5TY29wZUVudHJ5GiwKClNjb3BlRW50cnkSCwoD", + "a2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4AUJDWkFnaXRodWIuY29tL2dy", + "cGMtZWNvc3lzdGVtL2dycGMtZ2F0ZXdheS9wcm90b2MtZ2VuLXN3YWdnZXIv", + "b3B0aW9uc2IGcHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.AnyReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Swagger), global::Grpc.Gateway.ProtocGenSwagger.Options.Swagger.Parser, new[]{ "Swagger_", "Info", "Host", "BasePath", "Schemes", "Consumes", "Produces", "Responses", "SecurityDefinitions", "Security", "ExternalDocs", "Extensions" }, null, new[]{ typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Swagger.Types.SwaggerScheme) }, null, new pbr::GeneratedClrTypeInfo[] { null, null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Operation), global::Grpc.Gateway.ProtocGenSwagger.Options.Operation.Parser, new[]{ "Tags", "Summary", "Description", "ExternalDocs", "OperationId", "Consumes", "Produces", "Responses", "Schemes", "Deprecated", "Security", "Extensions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Response), global::Grpc.Gateway.ProtocGenSwagger.Options.Response.Parser, new[]{ "Description", "Schema", "Examples", "Extensions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Info), global::Grpc.Gateway.ProtocGenSwagger.Options.Info.Parser, new[]{ "Title", "Description", "TermsOfService", "Contact", "License", "Version", "Extensions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Contact), global::Grpc.Gateway.ProtocGenSwagger.Options.Contact.Parser, new[]{ "Name", "Url", "Email" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.License), global::Grpc.Gateway.ProtocGenSwagger.Options.License.Parser, new[]{ "Name", "Url" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation), global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation.Parser, new[]{ "Description", "Url" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Schema), global::Grpc.Gateway.ProtocGenSwagger.Options.Schema.Parser, new[]{ "JsonSchema", "Discriminator", "ReadOnly", "ExternalDocs", "Example" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema), global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema.Parser, new[]{ "Ref", "Title", "Description", "Default", "ReadOnly", "MultipleOf", "Maximum", "ExclusiveMaximum", "Minimum", "ExclusiveMinimum", "MaxLength", "MinLength", "Pattern", "MaxItems", "MinItems", "UniqueItems", "MaxProperties", "MinProperties", "Required", "Array", "Type" }, null, new[]{ typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema.Types.JSONSchemaSimpleTypes) }, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Tag), global::Grpc.Gateway.ProtocGenSwagger.Options.Tag.Parser, new[]{ "Description", "ExternalDocs" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions), global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions.Parser, new[]{ "Security" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme), global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Parser, new[]{ "Type", "Description", "Name", "In", "Flow", "AuthorizationUrl", "TokenUrl", "Scopes", "Extensions" }, null, new[]{ typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type), typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In), typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement), global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Parser, new[]{ "SecurityRequirement_" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Types.SecurityRequirementValue), global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Types.SecurityRequirementValue.Parser, new[]{ "Scope" }, null, null, null, null), + null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes), global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes.Parser, new[]{ "Scope" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }) + })); + } + #endregion + + } + #region Messages + /// + /// `Swagger` is a representation of OpenAPI v2 specification's Swagger object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#swaggerObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Swagger : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Swagger()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Swagger() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Swagger(Swagger other) : this() { + swagger_ = other.swagger_; + info_ = other.info_ != null ? other.info_.Clone() : null; + host_ = other.host_; + basePath_ = other.basePath_; + schemes_ = other.schemes_.Clone(); + consumes_ = other.consumes_.Clone(); + produces_ = other.produces_.Clone(); + responses_ = other.responses_.Clone(); + securityDefinitions_ = other.securityDefinitions_ != null ? other.securityDefinitions_.Clone() : null; + security_ = other.security_.Clone(); + externalDocs_ = other.externalDocs_ != null ? other.externalDocs_.Clone() : null; + extensions_ = other.extensions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Swagger Clone() { + return new Swagger(this); + } + + /// Field number for the "swagger" field. + public const int Swagger_FieldNumber = 1; + private string swagger_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Swagger_ { + get { return swagger_; } + set { + swagger_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::Grpc.Gateway.ProtocGenSwagger.Options.Info info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.Info Info { + get { return info_; } + set { + info_ = value; + } + } + + /// Field number for the "host" field. + public const int HostFieldNumber = 3; + private string host_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Host { + get { return host_; } + set { + host_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "base_path" field. + public const int BasePathFieldNumber = 4; + private string basePath_ = ""; + /// + /// `base_path` is the common prefix path used on all API endpoints (ie. /api, /v1, etc.). By adding this, + /// it allows you to remove this portion from the path endpoints in your Swagger file making them easier + /// to read. Note that using `base_path` does not change the endpoint paths that are generated in the resulting + /// Swagger file. If you wish to use `base_path` with relatively generated Swagger paths, the + /// `base_path` prefix must be manually removed from your `google.api.http` paths and your code changed to + /// serve the API from the `base_path`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string BasePath { + get { return basePath_; } + set { + basePath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "schemes" field. + public const int SchemesFieldNumber = 5; + private static readonly pb::FieldCodec _repeated_schemes_codec + = pb::FieldCodec.ForEnum(42, x => (int) x, x => (global::Grpc.Gateway.ProtocGenSwagger.Options.Swagger.Types.SwaggerScheme) x); + private readonly pbc::RepeatedField schemes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Schemes { + get { return schemes_; } + } + + /// Field number for the "consumes" field. + public const int ConsumesFieldNumber = 6; + private static readonly pb::FieldCodec _repeated_consumes_codec + = pb::FieldCodec.ForString(50); + private readonly pbc::RepeatedField consumes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Consumes { + get { return consumes_; } + } + + /// Field number for the "produces" field. + public const int ProducesFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_produces_codec + = pb::FieldCodec.ForString(58); + private readonly pbc::RepeatedField produces_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Produces { + get { return produces_; } + } + + /// Field number for the "responses" field. + public const int ResponsesFieldNumber = 10; + private static readonly pbc::MapField.Codec _map_responses_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Grpc.Gateway.ProtocGenSwagger.Options.Response.Parser), 82); + private readonly pbc::MapField responses_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Responses { + get { return responses_; } + } + + /// Field number for the "security_definitions" field. + public const int SecurityDefinitionsFieldNumber = 11; + private global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions securityDefinitions_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions SecurityDefinitions { + get { return securityDefinitions_; } + set { + securityDefinitions_ = value; + } + } + + /// Field number for the "security" field. + public const int SecurityFieldNumber = 12; + private static readonly pb::FieldCodec _repeated_security_codec + = pb::FieldCodec.ForMessage(98, global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Parser); + private readonly pbc::RepeatedField security_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Security { + get { return security_; } + } + + /// Field number for the "external_docs" field. + public const int ExternalDocsFieldNumber = 14; + private global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation externalDocs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation ExternalDocs { + get { return externalDocs_; } + set { + externalDocs_ = value; + } + } + + /// Field number for the "extensions" field. + public const int ExtensionsFieldNumber = 15; + private static readonly pbc::MapField.Codec _map_extensions_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Value.Parser), 122); + private readonly pbc::MapField extensions_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Extensions { + get { return extensions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Swagger); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Swagger other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Swagger_ != other.Swagger_) return false; + if (!object.Equals(Info, other.Info)) return false; + if (Host != other.Host) return false; + if (BasePath != other.BasePath) return false; + if(!schemes_.Equals(other.schemes_)) return false; + if(!consumes_.Equals(other.consumes_)) return false; + if(!produces_.Equals(other.produces_)) return false; + if (!Responses.Equals(other.Responses)) return false; + if (!object.Equals(SecurityDefinitions, other.SecurityDefinitions)) return false; + if(!security_.Equals(other.security_)) return false; + if (!object.Equals(ExternalDocs, other.ExternalDocs)) return false; + if (!Extensions.Equals(other.Extensions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Swagger_.Length != 0) hash ^= Swagger_.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); + if (Host.Length != 0) hash ^= Host.GetHashCode(); + if (BasePath.Length != 0) hash ^= BasePath.GetHashCode(); + hash ^= schemes_.GetHashCode(); + hash ^= consumes_.GetHashCode(); + hash ^= produces_.GetHashCode(); + hash ^= Responses.GetHashCode(); + if (securityDefinitions_ != null) hash ^= SecurityDefinitions.GetHashCode(); + hash ^= security_.GetHashCode(); + if (externalDocs_ != null) hash ^= ExternalDocs.GetHashCode(); + hash ^= Extensions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Swagger_.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Swagger_); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (Host.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Host); + } + if (BasePath.Length != 0) { + output.WriteRawTag(34); + output.WriteString(BasePath); + } + schemes_.WriteTo(output, _repeated_schemes_codec); + consumes_.WriteTo(output, _repeated_consumes_codec); + produces_.WriteTo(output, _repeated_produces_codec); + responses_.WriteTo(output, _map_responses_codec); + if (securityDefinitions_ != null) { + output.WriteRawTag(90); + output.WriteMessage(SecurityDefinitions); + } + security_.WriteTo(output, _repeated_security_codec); + if (externalDocs_ != null) { + output.WriteRawTag(114); + output.WriteMessage(ExternalDocs); + } + extensions_.WriteTo(output, _map_extensions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Swagger_.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Swagger_); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (Host.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Host); + } + if (BasePath.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(BasePath); + } + size += schemes_.CalculateSize(_repeated_schemes_codec); + size += consumes_.CalculateSize(_repeated_consumes_codec); + size += produces_.CalculateSize(_repeated_produces_codec); + size += responses_.CalculateSize(_map_responses_codec); + if (securityDefinitions_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityDefinitions); + } + size += security_.CalculateSize(_repeated_security_codec); + if (externalDocs_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExternalDocs); + } + size += extensions_.CalculateSize(_map_extensions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Swagger other) { + if (other == null) { + return; + } + if (other.Swagger_.Length != 0) { + Swagger_ = other.Swagger_; + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::Grpc.Gateway.ProtocGenSwagger.Options.Info(); + } + Info.MergeFrom(other.Info); + } + if (other.Host.Length != 0) { + Host = other.Host; + } + if (other.BasePath.Length != 0) { + BasePath = other.BasePath; + } + schemes_.Add(other.schemes_); + consumes_.Add(other.consumes_); + produces_.Add(other.produces_); + responses_.Add(other.responses_); + if (other.securityDefinitions_ != null) { + if (securityDefinitions_ == null) { + SecurityDefinitions = new global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions(); + } + SecurityDefinitions.MergeFrom(other.SecurityDefinitions); + } + security_.Add(other.security_); + if (other.externalDocs_ != null) { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + ExternalDocs.MergeFrom(other.ExternalDocs); + } + extensions_.Add(other.extensions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Swagger_ = input.ReadString(); + break; + } + case 18: { + if (info_ == null) { + Info = new global::Grpc.Gateway.ProtocGenSwagger.Options.Info(); + } + input.ReadMessage(Info); + break; + } + case 26: { + Host = input.ReadString(); + break; + } + case 34: { + BasePath = input.ReadString(); + break; + } + case 42: + case 40: { + schemes_.AddEntriesFrom(input, _repeated_schemes_codec); + break; + } + case 50: { + consumes_.AddEntriesFrom(input, _repeated_consumes_codec); + break; + } + case 58: { + produces_.AddEntriesFrom(input, _repeated_produces_codec); + break; + } + case 82: { + responses_.AddEntriesFrom(input, _map_responses_codec); + break; + } + case 90: { + if (securityDefinitions_ == null) { + SecurityDefinitions = new global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityDefinitions(); + } + input.ReadMessage(SecurityDefinitions); + break; + } + case 98: { + security_.AddEntriesFrom(input, _repeated_security_codec); + break; + } + case 114: { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + input.ReadMessage(ExternalDocs); + break; + } + case 122: { + extensions_.AddEntriesFrom(input, _map_extensions_codec); + break; + } + } + } + } + + #region Nested types + /// Container for nested types declared in the Swagger message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + internal enum SwaggerScheme { + [pbr::OriginalName("UNKNOWN")] Unknown = 0, + [pbr::OriginalName("HTTP")] Http = 1, + [pbr::OriginalName("HTTPS")] Https = 2, + [pbr::OriginalName("WS")] Ws = 3, + [pbr::OriginalName("WSS")] Wss = 4, + } + + } + #endregion + + } + + /// + /// `Operation` is a representation of OpenAPI v2 specification's Operation object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#operationObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Operation : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Operation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation(Operation other) : this() { + tags_ = other.tags_.Clone(); + summary_ = other.summary_; + description_ = other.description_; + externalDocs_ = other.externalDocs_ != null ? other.externalDocs_.Clone() : null; + operationId_ = other.operationId_; + consumes_ = other.consumes_.Clone(); + produces_ = other.produces_.Clone(); + responses_ = other.responses_.Clone(); + schemes_ = other.schemes_.Clone(); + deprecated_ = other.deprecated_; + security_ = other.security_.Clone(); + extensions_ = other.extensions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation Clone() { + return new Operation(this); + } + + /// Field number for the "tags" field. + public const int TagsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_tags_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField tags_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Tags { + get { return tags_; } + } + + /// Field number for the "summary" field. + public const int SummaryFieldNumber = 2; + private string summary_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Summary { + get { return summary_; } + set { + summary_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 3; + private string description_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "external_docs" field. + public const int ExternalDocsFieldNumber = 4; + private global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation externalDocs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation ExternalDocs { + get { return externalDocs_; } + set { + externalDocs_ = value; + } + } + + /// Field number for the "operation_id" field. + public const int OperationIdFieldNumber = 5; + private string operationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string OperationId { + get { return operationId_; } + set { + operationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "consumes" field. + public const int ConsumesFieldNumber = 6; + private static readonly pb::FieldCodec _repeated_consumes_codec + = pb::FieldCodec.ForString(50); + private readonly pbc::RepeatedField consumes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Consumes { + get { return consumes_; } + } + + /// Field number for the "produces" field. + public const int ProducesFieldNumber = 7; + private static readonly pb::FieldCodec _repeated_produces_codec + = pb::FieldCodec.ForString(58); + private readonly pbc::RepeatedField produces_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Produces { + get { return produces_; } + } + + /// Field number for the "responses" field. + public const int ResponsesFieldNumber = 9; + private static readonly pbc::MapField.Codec _map_responses_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Grpc.Gateway.ProtocGenSwagger.Options.Response.Parser), 74); + private readonly pbc::MapField responses_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Responses { + get { return responses_; } + } + + /// Field number for the "schemes" field. + public const int SchemesFieldNumber = 10; + private static readonly pb::FieldCodec _repeated_schemes_codec + = pb::FieldCodec.ForString(82); + private readonly pbc::RepeatedField schemes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Schemes { + get { return schemes_; } + } + + /// Field number for the "deprecated" field. + public const int DeprecatedFieldNumber = 11; + private bool deprecated_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Deprecated { + get { return deprecated_; } + set { + deprecated_ = value; + } + } + + /// Field number for the "security" field. + public const int SecurityFieldNumber = 12; + private static readonly pb::FieldCodec _repeated_security_codec + = pb::FieldCodec.ForMessage(98, global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Parser); + private readonly pbc::RepeatedField security_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Security { + get { return security_; } + } + + /// Field number for the "extensions" field. + public const int ExtensionsFieldNumber = 13; + private static readonly pbc::MapField.Codec _map_extensions_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Value.Parser), 106); + private readonly pbc::MapField extensions_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Extensions { + get { return extensions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Operation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Operation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!tags_.Equals(other.tags_)) return false; + if (Summary != other.Summary) return false; + if (Description != other.Description) return false; + if (!object.Equals(ExternalDocs, other.ExternalDocs)) return false; + if (OperationId != other.OperationId) return false; + if(!consumes_.Equals(other.consumes_)) return false; + if(!produces_.Equals(other.produces_)) return false; + if (!Responses.Equals(other.Responses)) return false; + if(!schemes_.Equals(other.schemes_)) return false; + if (Deprecated != other.Deprecated) return false; + if(!security_.Equals(other.security_)) return false; + if (!Extensions.Equals(other.Extensions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= tags_.GetHashCode(); + if (Summary.Length != 0) hash ^= Summary.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (externalDocs_ != null) hash ^= ExternalDocs.GetHashCode(); + if (OperationId.Length != 0) hash ^= OperationId.GetHashCode(); + hash ^= consumes_.GetHashCode(); + hash ^= produces_.GetHashCode(); + hash ^= Responses.GetHashCode(); + hash ^= schemes_.GetHashCode(); + if (Deprecated != false) hash ^= Deprecated.GetHashCode(); + hash ^= security_.GetHashCode(); + hash ^= Extensions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + tags_.WriteTo(output, _repeated_tags_codec); + if (Summary.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Summary); + } + if (Description.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Description); + } + if (externalDocs_ != null) { + output.WriteRawTag(34); + output.WriteMessage(ExternalDocs); + } + if (OperationId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(OperationId); + } + consumes_.WriteTo(output, _repeated_consumes_codec); + produces_.WriteTo(output, _repeated_produces_codec); + responses_.WriteTo(output, _map_responses_codec); + schemes_.WriteTo(output, _repeated_schemes_codec); + if (Deprecated != false) { + output.WriteRawTag(88); + output.WriteBool(Deprecated); + } + security_.WriteTo(output, _repeated_security_codec); + extensions_.WriteTo(output, _map_extensions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += tags_.CalculateSize(_repeated_tags_codec); + if (Summary.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Summary); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (externalDocs_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExternalDocs); + } + if (OperationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OperationId); + } + size += consumes_.CalculateSize(_repeated_consumes_codec); + size += produces_.CalculateSize(_repeated_produces_codec); + size += responses_.CalculateSize(_map_responses_codec); + size += schemes_.CalculateSize(_repeated_schemes_codec); + if (Deprecated != false) { + size += 1 + 1; + } + size += security_.CalculateSize(_repeated_security_codec); + size += extensions_.CalculateSize(_map_extensions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Operation other) { + if (other == null) { + return; + } + tags_.Add(other.tags_); + if (other.Summary.Length != 0) { + Summary = other.Summary; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.externalDocs_ != null) { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + ExternalDocs.MergeFrom(other.ExternalDocs); + } + if (other.OperationId.Length != 0) { + OperationId = other.OperationId; + } + consumes_.Add(other.consumes_); + produces_.Add(other.produces_); + responses_.Add(other.responses_); + schemes_.Add(other.schemes_); + if (other.Deprecated != false) { + Deprecated = other.Deprecated; + } + security_.Add(other.security_); + extensions_.Add(other.extensions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + tags_.AddEntriesFrom(input, _repeated_tags_codec); + break; + } + case 18: { + Summary = input.ReadString(); + break; + } + case 26: { + Description = input.ReadString(); + break; + } + case 34: { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + input.ReadMessage(ExternalDocs); + break; + } + case 42: { + OperationId = input.ReadString(); + break; + } + case 50: { + consumes_.AddEntriesFrom(input, _repeated_consumes_codec); + break; + } + case 58: { + produces_.AddEntriesFrom(input, _repeated_produces_codec); + break; + } + case 74: { + responses_.AddEntriesFrom(input, _map_responses_codec); + break; + } + case 82: { + schemes_.AddEntriesFrom(input, _repeated_schemes_codec); + break; + } + case 88: { + Deprecated = input.ReadBool(); + break; + } + case 98: { + security_.AddEntriesFrom(input, _repeated_security_codec); + break; + } + case 106: { + extensions_.AddEntriesFrom(input, _map_extensions_codec); + break; + } + } + } + } + + } + + /// + /// `Response` is a representation of OpenAPI v2 specification's Response object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#responseObject + /// + internal sealed partial class Response : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Response()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Response() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Response(Response other) : this() { + description_ = other.description_; + schema_ = other.schema_ != null ? other.schema_.Clone() : null; + examples_ = other.examples_.Clone(); + extensions_ = other.extensions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Response Clone() { + return new Response(this); + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 1; + private string description_ = ""; + /// + /// `Description` is a short description of the response. + /// GFM syntax can be used for rich text representation. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "schema" field. + public const int SchemaFieldNumber = 2; + private global::Grpc.Gateway.ProtocGenSwagger.Options.Schema schema_; + /// + /// `Schema` optionally defines the structure of the response. + /// If `Schema` is not provided, it means there is no content to the response. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.Schema Schema { + get { return schema_; } + set { + schema_ = value; + } + } + + /// Field number for the "examples" field. + public const int ExamplesFieldNumber = 4; + private static readonly pbc::MapField.Codec _map_examples_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 34); + private readonly pbc::MapField examples_ = new pbc::MapField(); + /// + /// `Examples` gives per-mimetype response examples. + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Examples { + get { return examples_; } + } + + /// Field number for the "extensions" field. + public const int ExtensionsFieldNumber = 5; + private static readonly pbc::MapField.Codec _map_extensions_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Value.Parser), 42); + private readonly pbc::MapField extensions_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Extensions { + get { return extensions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Response); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Response other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Description != other.Description) return false; + if (!object.Equals(Schema, other.Schema)) return false; + if (!Examples.Equals(other.Examples)) return false; + if (!Extensions.Equals(other.Extensions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (schema_ != null) hash ^= Schema.GetHashCode(); + hash ^= Examples.GetHashCode(); + hash ^= Extensions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Description.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Description); + } + if (schema_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Schema); + } + examples_.WriteTo(output, _map_examples_codec); + extensions_.WriteTo(output, _map_extensions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (schema_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Schema); + } + size += examples_.CalculateSize(_map_examples_codec); + size += extensions_.CalculateSize(_map_extensions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Response other) { + if (other == null) { + return; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.schema_ != null) { + if (schema_ == null) { + Schema = new global::Grpc.Gateway.ProtocGenSwagger.Options.Schema(); + } + Schema.MergeFrom(other.Schema); + } + examples_.Add(other.examples_); + extensions_.Add(other.extensions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Description = input.ReadString(); + break; + } + case 18: { + if (schema_ == null) { + Schema = new global::Grpc.Gateway.ProtocGenSwagger.Options.Schema(); + } + input.ReadMessage(Schema); + break; + } + case 34: { + examples_.AddEntriesFrom(input, _map_examples_codec); + break; + } + case 42: { + extensions_.AddEntriesFrom(input, _map_extensions_codec); + break; + } + } + } + } + + } + + /// + /// `Info` is a representation of OpenAPI v2 specification's Info object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#infoObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Info : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Info()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Info() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Info(Info other) : this() { + title_ = other.title_; + description_ = other.description_; + termsOfService_ = other.termsOfService_; + contact_ = other.contact_ != null ? other.contact_.Clone() : null; + license_ = other.license_ != null ? other.license_.Clone() : null; + version_ = other.version_; + extensions_ = other.extensions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Info Clone() { + return new Info(this); + } + + /// Field number for the "title" field. + public const int TitleFieldNumber = 1; + private string title_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Title { + get { return title_; } + set { + title_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 2; + private string description_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "terms_of_service" field. + public const int TermsOfServiceFieldNumber = 3; + private string termsOfService_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string TermsOfService { + get { return termsOfService_; } + set { + termsOfService_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "contact" field. + public const int ContactFieldNumber = 4; + private global::Grpc.Gateway.ProtocGenSwagger.Options.Contact contact_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.Contact Contact { + get { return contact_; } + set { + contact_ = value; + } + } + + /// Field number for the "license" field. + public const int LicenseFieldNumber = 5; + private global::Grpc.Gateway.ProtocGenSwagger.Options.License license_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.License License { + get { return license_; } + set { + license_ = value; + } + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 6; + private string version_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Version { + get { return version_; } + set { + version_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "extensions" field. + public const int ExtensionsFieldNumber = 7; + private static readonly pbc::MapField.Codec _map_extensions_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Value.Parser), 58); + private readonly pbc::MapField extensions_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Extensions { + get { return extensions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Info); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Info other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Title != other.Title) return false; + if (Description != other.Description) return false; + if (TermsOfService != other.TermsOfService) return false; + if (!object.Equals(Contact, other.Contact)) return false; + if (!object.Equals(License, other.License)) return false; + if (Version != other.Version) return false; + if (!Extensions.Equals(other.Extensions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Title.Length != 0) hash ^= Title.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (TermsOfService.Length != 0) hash ^= TermsOfService.GetHashCode(); + if (contact_ != null) hash ^= Contact.GetHashCode(); + if (license_ != null) hash ^= License.GetHashCode(); + if (Version.Length != 0) hash ^= Version.GetHashCode(); + hash ^= Extensions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Title.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Title); + } + if (Description.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Description); + } + if (TermsOfService.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TermsOfService); + } + if (contact_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Contact); + } + if (license_ != null) { + output.WriteRawTag(42); + output.WriteMessage(License); + } + if (Version.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Version); + } + extensions_.WriteTo(output, _map_extensions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Title.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Title); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (TermsOfService.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TermsOfService); + } + if (contact_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Contact); + } + if (license_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(License); + } + if (Version.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Version); + } + size += extensions_.CalculateSize(_map_extensions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Info other) { + if (other == null) { + return; + } + if (other.Title.Length != 0) { + Title = other.Title; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.TermsOfService.Length != 0) { + TermsOfService = other.TermsOfService; + } + if (other.contact_ != null) { + if (contact_ == null) { + Contact = new global::Grpc.Gateway.ProtocGenSwagger.Options.Contact(); + } + Contact.MergeFrom(other.Contact); + } + if (other.license_ != null) { + if (license_ == null) { + License = new global::Grpc.Gateway.ProtocGenSwagger.Options.License(); + } + License.MergeFrom(other.License); + } + if (other.Version.Length != 0) { + Version = other.Version; + } + extensions_.Add(other.extensions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Title = input.ReadString(); + break; + } + case 18: { + Description = input.ReadString(); + break; + } + case 26: { + TermsOfService = input.ReadString(); + break; + } + case 34: { + if (contact_ == null) { + Contact = new global::Grpc.Gateway.ProtocGenSwagger.Options.Contact(); + } + input.ReadMessage(Contact); + break; + } + case 42: { + if (license_ == null) { + License = new global::Grpc.Gateway.ProtocGenSwagger.Options.License(); + } + input.ReadMessage(License); + break; + } + case 50: { + Version = input.ReadString(); + break; + } + case 58: { + extensions_.AddEntriesFrom(input, _map_extensions_codec); + break; + } + } + } + } + + } + + /// + /// `Contact` is a representation of OpenAPI v2 specification's Contact object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#contactObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Contact : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Contact()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Contact() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Contact(Contact other) : this() { + name_ = other.name_; + url_ = other.url_; + email_ = other.email_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Contact Clone() { + return new Contact(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "url" field. + public const int UrlFieldNumber = 2; + private string url_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Url { + get { return url_; } + set { + url_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "email" field. + public const int EmailFieldNumber = 3; + private string email_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Email { + get { return email_; } + set { + email_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Contact); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Contact other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Url != other.Url) return false; + if (Email != other.Email) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Url.Length != 0) hash ^= Url.GetHashCode(); + if (Email.Length != 0) hash ^= Email.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Url.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Url); + } + if (Email.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Email); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Url.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Url); + } + if (Email.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Email); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Contact other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Url.Length != 0) { + Url = other.Url; + } + if (other.Email.Length != 0) { + Email = other.Email; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Url = input.ReadString(); + break; + } + case 26: { + Email = input.ReadString(); + break; + } + } + } + } + + } + + /// + /// `License` is a representation of OpenAPI v2 specification's License object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#licenseObject + /// + internal sealed partial class License : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new License()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public License() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public License(License other) : this() { + name_ = other.name_; + url_ = other.url_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public License Clone() { + return new License(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + /// + /// Required. The license name used for the API. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "url" field. + public const int UrlFieldNumber = 2; + private string url_ = ""; + /// + /// A URL to the license used for the API. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Url { + get { return url_; } + set { + url_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as License); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(License other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Url != other.Url) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Url.Length != 0) hash ^= Url.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Url.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Url); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Url.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Url); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(License other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Url.Length != 0) { + Url = other.Url; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Url = input.ReadString(); + break; + } + } + } + } + + } + + /// + /// `ExternalDocumentation` is a representation of OpenAPI v2 specification's + /// ExternalDocumentation object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#externalDocumentationObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class ExternalDocumentation : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExternalDocumentation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ExternalDocumentation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ExternalDocumentation(ExternalDocumentation other) : this() { + description_ = other.description_; + url_ = other.url_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ExternalDocumentation Clone() { + return new ExternalDocumentation(this); + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 1; + private string description_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "url" field. + public const int UrlFieldNumber = 2; + private string url_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Url { + get { return url_; } + set { + url_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ExternalDocumentation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ExternalDocumentation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Description != other.Description) return false; + if (Url != other.Url) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (Url.Length != 0) hash ^= Url.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Description.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Description); + } + if (Url.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Url); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (Url.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Url); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ExternalDocumentation other) { + if (other == null) { + return; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.Url.Length != 0) { + Url = other.Url; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Description = input.ReadString(); + break; + } + case 18: { + Url = input.ReadString(); + break; + } + } + } + } + + } + + /// + /// `Schema` is a representation of OpenAPI v2 specification's Schema object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Schema : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Schema()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Schema() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Schema(Schema other) : this() { + jsonSchema_ = other.jsonSchema_ != null ? other.jsonSchema_.Clone() : null; + discriminator_ = other.discriminator_; + readOnly_ = other.readOnly_; + externalDocs_ = other.externalDocs_ != null ? other.externalDocs_.Clone() : null; + example_ = other.example_ != null ? other.example_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Schema Clone() { + return new Schema(this); + } + + /// Field number for the "json_schema" field. + public const int JsonSchemaFieldNumber = 1; + private global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema jsonSchema_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema JsonSchema { + get { return jsonSchema_; } + set { + jsonSchema_ = value; + } + } + + /// Field number for the "discriminator" field. + public const int DiscriminatorFieldNumber = 2; + private string discriminator_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Discriminator { + get { return discriminator_; } + set { + discriminator_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "read_only" field. + public const int ReadOnlyFieldNumber = 3; + private bool readOnly_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool ReadOnly { + get { return readOnly_; } + set { + readOnly_ = value; + } + } + + /// Field number for the "external_docs" field. + public const int ExternalDocsFieldNumber = 5; + private global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation externalDocs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation ExternalDocs { + get { return externalDocs_; } + set { + externalDocs_ = value; + } + } + + /// Field number for the "example" field. + public const int ExampleFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Any example_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Any Example { + get { return example_; } + set { + example_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Schema); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Schema other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(JsonSchema, other.JsonSchema)) return false; + if (Discriminator != other.Discriminator) return false; + if (ReadOnly != other.ReadOnly) return false; + if (!object.Equals(ExternalDocs, other.ExternalDocs)) return false; + if (!object.Equals(Example, other.Example)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (jsonSchema_ != null) hash ^= JsonSchema.GetHashCode(); + if (Discriminator.Length != 0) hash ^= Discriminator.GetHashCode(); + if (ReadOnly != false) hash ^= ReadOnly.GetHashCode(); + if (externalDocs_ != null) hash ^= ExternalDocs.GetHashCode(); + if (example_ != null) hash ^= Example.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (jsonSchema_ != null) { + output.WriteRawTag(10); + output.WriteMessage(JsonSchema); + } + if (Discriminator.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Discriminator); + } + if (ReadOnly != false) { + output.WriteRawTag(24); + output.WriteBool(ReadOnly); + } + if (externalDocs_ != null) { + output.WriteRawTag(42); + output.WriteMessage(ExternalDocs); + } + if (example_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Example); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (jsonSchema_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(JsonSchema); + } + if (Discriminator.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Discriminator); + } + if (ReadOnly != false) { + size += 1 + 1; + } + if (externalDocs_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExternalDocs); + } + if (example_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Example); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Schema other) { + if (other == null) { + return; + } + if (other.jsonSchema_ != null) { + if (jsonSchema_ == null) { + JsonSchema = new global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema(); + } + JsonSchema.MergeFrom(other.JsonSchema); + } + if (other.Discriminator.Length != 0) { + Discriminator = other.Discriminator; + } + if (other.ReadOnly != false) { + ReadOnly = other.ReadOnly; + } + if (other.externalDocs_ != null) { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + ExternalDocs.MergeFrom(other.ExternalDocs); + } + if (other.example_ != null) { + if (example_ == null) { + Example = new global::Google.Protobuf.WellKnownTypes.Any(); + } + Example.MergeFrom(other.Example); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (jsonSchema_ == null) { + JsonSchema = new global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema(); + } + input.ReadMessage(JsonSchema); + break; + } + case 18: { + Discriminator = input.ReadString(); + break; + } + case 24: { + ReadOnly = input.ReadBool(); + break; + } + case 42: { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + input.ReadMessage(ExternalDocs); + break; + } + case 50: { + if (example_ == null) { + Example = new global::Google.Protobuf.WellKnownTypes.Any(); + } + input.ReadMessage(Example); + break; + } + } + } + } + + } + + /// + /// `JSONSchema` represents properties from JSON Schema taken, and as used, in + /// the OpenAPI v2 spec. + /// + /// This includes changes made by OpenAPI v2. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + /// + /// See also: https://cswr.github.io/JsonSchema/spec/basic_types/, + /// https://github.com/json-schema-org/json-schema-spec/blob/master/schema.json + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class JSONSchema : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new JSONSchema()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public JSONSchema() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public JSONSchema(JSONSchema other) : this() { + ref_ = other.ref_; + title_ = other.title_; + description_ = other.description_; + default_ = other.default_; + readOnly_ = other.readOnly_; + multipleOf_ = other.multipleOf_; + maximum_ = other.maximum_; + exclusiveMaximum_ = other.exclusiveMaximum_; + minimum_ = other.minimum_; + exclusiveMinimum_ = other.exclusiveMinimum_; + maxLength_ = other.maxLength_; + minLength_ = other.minLength_; + pattern_ = other.pattern_; + maxItems_ = other.maxItems_; + minItems_ = other.minItems_; + uniqueItems_ = other.uniqueItems_; + maxProperties_ = other.maxProperties_; + minProperties_ = other.minProperties_; + required_ = other.required_.Clone(); + array_ = other.array_.Clone(); + type_ = other.type_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public JSONSchema Clone() { + return new JSONSchema(this); + } + + /// Field number for the "ref" field. + public const int RefFieldNumber = 3; + private string ref_ = ""; + /// + /// Ref is used to define an external reference to include in the message. + /// This could be a fully qualified proto message reference, and that type must be imported + /// into the protofile. If no message is identified, the Ref will be used verbatim in + /// the output. + /// For example: + /// `ref: ".google.protobuf.Timestamp"`. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Ref { + get { return ref_; } + set { + ref_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "title" field. + public const int TitleFieldNumber = 5; + private string title_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Title { + get { return title_; } + set { + title_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 6; + private string description_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "default" field. + public const int DefaultFieldNumber = 7; + private string default_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Default { + get { return default_; } + set { + default_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "read_only" field. + public const int ReadOnlyFieldNumber = 8; + private bool readOnly_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool ReadOnly { + get { return readOnly_; } + set { + readOnly_ = value; + } + } + + /// Field number for the "multiple_of" field. + public const int MultipleOfFieldNumber = 10; + private double multipleOf_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double MultipleOf { + get { return multipleOf_; } + set { + multipleOf_ = value; + } + } + + /// Field number for the "maximum" field. + public const int MaximumFieldNumber = 11; + private double maximum_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Maximum { + get { return maximum_; } + set { + maximum_ = value; + } + } + + /// Field number for the "exclusive_maximum" field. + public const int ExclusiveMaximumFieldNumber = 12; + private bool exclusiveMaximum_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool ExclusiveMaximum { + get { return exclusiveMaximum_; } + set { + exclusiveMaximum_ = value; + } + } + + /// Field number for the "minimum" field. + public const int MinimumFieldNumber = 13; + private double minimum_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double Minimum { + get { return minimum_; } + set { + minimum_ = value; + } + } + + /// Field number for the "exclusive_minimum" field. + public const int ExclusiveMinimumFieldNumber = 14; + private bool exclusiveMinimum_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool ExclusiveMinimum { + get { return exclusiveMinimum_; } + set { + exclusiveMinimum_ = value; + } + } + + /// Field number for the "max_length" field. + public const int MaxLengthFieldNumber = 15; + private ulong maxLength_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MaxLength { + get { return maxLength_; } + set { + maxLength_ = value; + } + } + + /// Field number for the "min_length" field. + public const int MinLengthFieldNumber = 16; + private ulong minLength_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MinLength { + get { return minLength_; } + set { + minLength_ = value; + } + } + + /// Field number for the "pattern" field. + public const int PatternFieldNumber = 17; + private string pattern_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Pattern { + get { return pattern_; } + set { + pattern_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "max_items" field. + public const int MaxItemsFieldNumber = 20; + private ulong maxItems_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MaxItems { + get { return maxItems_; } + set { + maxItems_ = value; + } + } + + /// Field number for the "min_items" field. + public const int MinItemsFieldNumber = 21; + private ulong minItems_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MinItems { + get { return minItems_; } + set { + minItems_ = value; + } + } + + /// Field number for the "unique_items" field. + public const int UniqueItemsFieldNumber = 22; + private bool uniqueItems_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool UniqueItems { + get { return uniqueItems_; } + set { + uniqueItems_ = value; + } + } + + /// Field number for the "max_properties" field. + public const int MaxPropertiesFieldNumber = 24; + private ulong maxProperties_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MaxProperties { + get { return maxProperties_; } + set { + maxProperties_ = value; + } + } + + /// Field number for the "min_properties" field. + public const int MinPropertiesFieldNumber = 25; + private ulong minProperties_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong MinProperties { + get { return minProperties_; } + set { + minProperties_ = value; + } + } + + /// Field number for the "required" field. + public const int RequiredFieldNumber = 26; + private static readonly pb::FieldCodec _repeated_required_codec + = pb::FieldCodec.ForString(210); + private readonly pbc::RepeatedField required_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Required { + get { return required_; } + } + + /// Field number for the "array" field. + public const int ArrayFieldNumber = 34; + private static readonly pb::FieldCodec _repeated_array_codec + = pb::FieldCodec.ForString(274); + private readonly pbc::RepeatedField array_ = new pbc::RepeatedField(); + /// + /// Items in 'array' must be unique. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Array { + get { return array_; } + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 35; + private static readonly pb::FieldCodec _repeated_type_codec + = pb::FieldCodec.ForEnum(282, x => (int) x, x => (global::Grpc.Gateway.ProtocGenSwagger.Options.JSONSchema.Types.JSONSchemaSimpleTypes) x); + private readonly pbc::RepeatedField type_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Type { + get { return type_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as JSONSchema); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(JSONSchema other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Ref != other.Ref) return false; + if (Title != other.Title) return false; + if (Description != other.Description) return false; + if (Default != other.Default) return false; + if (ReadOnly != other.ReadOnly) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MultipleOf, other.MultipleOf)) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Maximum, other.Maximum)) return false; + if (ExclusiveMaximum != other.ExclusiveMaximum) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Minimum, other.Minimum)) return false; + if (ExclusiveMinimum != other.ExclusiveMinimum) return false; + if (MaxLength != other.MaxLength) return false; + if (MinLength != other.MinLength) return false; + if (Pattern != other.Pattern) return false; + if (MaxItems != other.MaxItems) return false; + if (MinItems != other.MinItems) return false; + if (UniqueItems != other.UniqueItems) return false; + if (MaxProperties != other.MaxProperties) return false; + if (MinProperties != other.MinProperties) return false; + if(!required_.Equals(other.required_)) return false; + if(!array_.Equals(other.array_)) return false; + if(!type_.Equals(other.type_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Ref.Length != 0) hash ^= Ref.GetHashCode(); + if (Title.Length != 0) hash ^= Title.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (Default.Length != 0) hash ^= Default.GetHashCode(); + if (ReadOnly != false) hash ^= ReadOnly.GetHashCode(); + if (MultipleOf != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MultipleOf); + if (Maximum != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Maximum); + if (ExclusiveMaximum != false) hash ^= ExclusiveMaximum.GetHashCode(); + if (Minimum != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Minimum); + if (ExclusiveMinimum != false) hash ^= ExclusiveMinimum.GetHashCode(); + if (MaxLength != 0UL) hash ^= MaxLength.GetHashCode(); + if (MinLength != 0UL) hash ^= MinLength.GetHashCode(); + if (Pattern.Length != 0) hash ^= Pattern.GetHashCode(); + if (MaxItems != 0UL) hash ^= MaxItems.GetHashCode(); + if (MinItems != 0UL) hash ^= MinItems.GetHashCode(); + if (UniqueItems != false) hash ^= UniqueItems.GetHashCode(); + if (MaxProperties != 0UL) hash ^= MaxProperties.GetHashCode(); + if (MinProperties != 0UL) hash ^= MinProperties.GetHashCode(); + hash ^= required_.GetHashCode(); + hash ^= array_.GetHashCode(); + hash ^= type_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Ref.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Ref); + } + if (Title.Length != 0) { + output.WriteRawTag(42); + output.WriteString(Title); + } + if (Description.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Description); + } + if (Default.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Default); + } + if (ReadOnly != false) { + output.WriteRawTag(64); + output.WriteBool(ReadOnly); + } + if (MultipleOf != 0D) { + output.WriteRawTag(81); + output.WriteDouble(MultipleOf); + } + if (Maximum != 0D) { + output.WriteRawTag(89); + output.WriteDouble(Maximum); + } + if (ExclusiveMaximum != false) { + output.WriteRawTag(96); + output.WriteBool(ExclusiveMaximum); + } + if (Minimum != 0D) { + output.WriteRawTag(105); + output.WriteDouble(Minimum); + } + if (ExclusiveMinimum != false) { + output.WriteRawTag(112); + output.WriteBool(ExclusiveMinimum); + } + if (MaxLength != 0UL) { + output.WriteRawTag(120); + output.WriteUInt64(MaxLength); + } + if (MinLength != 0UL) { + output.WriteRawTag(128, 1); + output.WriteUInt64(MinLength); + } + if (Pattern.Length != 0) { + output.WriteRawTag(138, 1); + output.WriteString(Pattern); + } + if (MaxItems != 0UL) { + output.WriteRawTag(160, 1); + output.WriteUInt64(MaxItems); + } + if (MinItems != 0UL) { + output.WriteRawTag(168, 1); + output.WriteUInt64(MinItems); + } + if (UniqueItems != false) { + output.WriteRawTag(176, 1); + output.WriteBool(UniqueItems); + } + if (MaxProperties != 0UL) { + output.WriteRawTag(192, 1); + output.WriteUInt64(MaxProperties); + } + if (MinProperties != 0UL) { + output.WriteRawTag(200, 1); + output.WriteUInt64(MinProperties); + } + required_.WriteTo(output, _repeated_required_codec); + array_.WriteTo(output, _repeated_array_codec); + type_.WriteTo(output, _repeated_type_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Ref.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Ref); + } + if (Title.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Title); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (Default.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Default); + } + if (ReadOnly != false) { + size += 1 + 1; + } + if (MultipleOf != 0D) { + size += 1 + 8; + } + if (Maximum != 0D) { + size += 1 + 8; + } + if (ExclusiveMaximum != false) { + size += 1 + 1; + } + if (Minimum != 0D) { + size += 1 + 8; + } + if (ExclusiveMinimum != false) { + size += 1 + 1; + } + if (MaxLength != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(MaxLength); + } + if (MinLength != 0UL) { + size += 2 + pb::CodedOutputStream.ComputeUInt64Size(MinLength); + } + if (Pattern.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(Pattern); + } + if (MaxItems != 0UL) { + size += 2 + pb::CodedOutputStream.ComputeUInt64Size(MaxItems); + } + if (MinItems != 0UL) { + size += 2 + pb::CodedOutputStream.ComputeUInt64Size(MinItems); + } + if (UniqueItems != false) { + size += 2 + 1; + } + if (MaxProperties != 0UL) { + size += 2 + pb::CodedOutputStream.ComputeUInt64Size(MaxProperties); + } + if (MinProperties != 0UL) { + size += 2 + pb::CodedOutputStream.ComputeUInt64Size(MinProperties); + } + size += required_.CalculateSize(_repeated_required_codec); + size += array_.CalculateSize(_repeated_array_codec); + size += type_.CalculateSize(_repeated_type_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(JSONSchema other) { + if (other == null) { + return; + } + if (other.Ref.Length != 0) { + Ref = other.Ref; + } + if (other.Title.Length != 0) { + Title = other.Title; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.Default.Length != 0) { + Default = other.Default; + } + if (other.ReadOnly != false) { + ReadOnly = other.ReadOnly; + } + if (other.MultipleOf != 0D) { + MultipleOf = other.MultipleOf; + } + if (other.Maximum != 0D) { + Maximum = other.Maximum; + } + if (other.ExclusiveMaximum != false) { + ExclusiveMaximum = other.ExclusiveMaximum; + } + if (other.Minimum != 0D) { + Minimum = other.Minimum; + } + if (other.ExclusiveMinimum != false) { + ExclusiveMinimum = other.ExclusiveMinimum; + } + if (other.MaxLength != 0UL) { + MaxLength = other.MaxLength; + } + if (other.MinLength != 0UL) { + MinLength = other.MinLength; + } + if (other.Pattern.Length != 0) { + Pattern = other.Pattern; + } + if (other.MaxItems != 0UL) { + MaxItems = other.MaxItems; + } + if (other.MinItems != 0UL) { + MinItems = other.MinItems; + } + if (other.UniqueItems != false) { + UniqueItems = other.UniqueItems; + } + if (other.MaxProperties != 0UL) { + MaxProperties = other.MaxProperties; + } + if (other.MinProperties != 0UL) { + MinProperties = other.MinProperties; + } + required_.Add(other.required_); + array_.Add(other.array_); + type_.Add(other.type_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 26: { + Ref = input.ReadString(); + break; + } + case 42: { + Title = input.ReadString(); + break; + } + case 50: { + Description = input.ReadString(); + break; + } + case 58: { + Default = input.ReadString(); + break; + } + case 64: { + ReadOnly = input.ReadBool(); + break; + } + case 81: { + MultipleOf = input.ReadDouble(); + break; + } + case 89: { + Maximum = input.ReadDouble(); + break; + } + case 96: { + ExclusiveMaximum = input.ReadBool(); + break; + } + case 105: { + Minimum = input.ReadDouble(); + break; + } + case 112: { + ExclusiveMinimum = input.ReadBool(); + break; + } + case 120: { + MaxLength = input.ReadUInt64(); + break; + } + case 128: { + MinLength = input.ReadUInt64(); + break; + } + case 138: { + Pattern = input.ReadString(); + break; + } + case 160: { + MaxItems = input.ReadUInt64(); + break; + } + case 168: { + MinItems = input.ReadUInt64(); + break; + } + case 176: { + UniqueItems = input.ReadBool(); + break; + } + case 192: { + MaxProperties = input.ReadUInt64(); + break; + } + case 200: { + MinProperties = input.ReadUInt64(); + break; + } + case 210: { + required_.AddEntriesFrom(input, _repeated_required_codec); + break; + } + case 274: { + array_.AddEntriesFrom(input, _repeated_array_codec); + break; + } + case 282: + case 280: { + type_.AddEntriesFrom(input, _repeated_type_codec); + break; + } + } + } + } + + #region Nested types + /// Container for nested types declared in the JSONSchema message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + internal enum JSONSchemaSimpleTypes { + [pbr::OriginalName("UNKNOWN")] Unknown = 0, + [pbr::OriginalName("ARRAY")] Array = 1, + [pbr::OriginalName("BOOLEAN")] Boolean = 2, + [pbr::OriginalName("INTEGER")] Integer = 3, + [pbr::OriginalName("NULL")] Null = 4, + [pbr::OriginalName("NUMBER")] Number = 5, + [pbr::OriginalName("OBJECT")] Object = 6, + [pbr::OriginalName("STRING")] String = 7, + } + + } + #endregion + + } + + /// + /// `Tag` is a representation of OpenAPI v2 specification's Tag object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#tagObject + /// + /// TODO(ivucica): document fields + /// + internal sealed partial class Tag : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Tag()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Tag() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Tag(Tag other) : this() { + description_ = other.description_; + externalDocs_ = other.externalDocs_ != null ? other.externalDocs_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Tag Clone() { + return new Tag(this); + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 2; + private string description_ = ""; + /// + /// TODO(ivucica): Description should be extracted from comments on the proto + /// service object. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "external_docs" field. + public const int ExternalDocsFieldNumber = 3; + private global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation externalDocs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation ExternalDocs { + get { return externalDocs_; } + set { + externalDocs_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Tag); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Tag other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Description != other.Description) return false; + if (!object.Equals(ExternalDocs, other.ExternalDocs)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (externalDocs_ != null) hash ^= ExternalDocs.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Description.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Description); + } + if (externalDocs_ != null) { + output.WriteRawTag(26); + output.WriteMessage(ExternalDocs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (externalDocs_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExternalDocs); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Tag other) { + if (other == null) { + return; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.externalDocs_ != null) { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + ExternalDocs.MergeFrom(other.ExternalDocs); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 18: { + Description = input.ReadString(); + break; + } + case 26: { + if (externalDocs_ == null) { + ExternalDocs = new global::Grpc.Gateway.ProtocGenSwagger.Options.ExternalDocumentation(); + } + input.ReadMessage(ExternalDocs); + break; + } + } + } + } + + } + + /// + /// `SecurityDefinitions` is a representation of OpenAPI v2 specification's + /// Security Definitions object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityDefinitionsObject + /// + /// A declaration of the security schemes available to be used in the + /// specification. This does not enforce the security schemes on the operations + /// and only serves to provide the relevant details for each scheme. + /// + internal sealed partial class SecurityDefinitions : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SecurityDefinitions()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityDefinitions() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityDefinitions(SecurityDefinitions other) : this() { + security_ = other.security_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityDefinitions Clone() { + return new SecurityDefinitions(this); + } + + /// Field number for the "security" field. + public const int SecurityFieldNumber = 1; + private static readonly pbc::MapField.Codec _map_security_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Parser), 10); + private readonly pbc::MapField security_ = new pbc::MapField(); + /// + /// A single security scheme definition, mapping a "name" to the scheme it defines. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Security { + get { return security_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SecurityDefinitions); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SecurityDefinitions other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Security.Equals(other.Security)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= Security.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + security_.WriteTo(output, _map_security_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += security_.CalculateSize(_map_security_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SecurityDefinitions other) { + if (other == null) { + return; + } + security_.Add(other.security_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + security_.AddEntriesFrom(input, _map_security_codec); + break; + } + } + } + } + + } + + /// + /// `SecurityScheme` is a representation of OpenAPI v2 specification's + /// Security Scheme object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securitySchemeObject + /// + /// Allows the definition of a security scheme that can be used by the + /// operations. Supported schemes are basic authentication, an API key (either as + /// a header or as a query parameter) and OAuth2's common flows (implicit, + /// password, application and access code). + /// + internal sealed partial class SecurityScheme : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SecurityScheme()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityScheme() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityScheme(SecurityScheme other) : this() { + type_ = other.type_; + description_ = other.description_; + name_ = other.name_; + in_ = other.in_; + flow_ = other.flow_; + authorizationUrl_ = other.authorizationUrl_; + tokenUrl_ = other.tokenUrl_; + scopes_ = other.scopes_ != null ? other.scopes_.Clone() : null; + extensions_ = other.extensions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityScheme Clone() { + return new SecurityScheme(this); + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 1; + private global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type type_ = global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type.Invalid; + /// + /// Required. The type of the security scheme. Valid values are "basic", + /// "apiKey" or "oauth2". + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 2; + private string description_ = ""; + /// + /// A short description for security scheme. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Description { + get { return description_; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 3; + private string name_ = ""; + /// + /// Required. The name of the header or query parameter to be used. + /// + /// Valid for apiKey. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "in" field. + public const int InFieldNumber = 4; + private global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In in_ = global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In.Invalid; + /// + /// Required. The location of the API key. Valid values are "query" or "header". + /// + /// Valid for apiKey. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In In { + get { return in_; } + set { + in_ = value; + } + } + + /// Field number for the "flow" field. + public const int FlowFieldNumber = 5; + private global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow flow_ = global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow.Invalid; + /// + /// Required. The flow used by the OAuth2 security scheme. Valid values are + /// "implicit", "password", "application" or "accessCode". + /// + /// Valid for oauth2. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow Flow { + get { return flow_; } + set { + flow_ = value; + } + } + + /// Field number for the "authorization_url" field. + public const int AuthorizationUrlFieldNumber = 6; + private string authorizationUrl_ = ""; + /// + /// Required. The authorization URL to be used for this flow. This SHOULD be in + /// the form of a URL. + /// + /// Valid for oauth2/implicit and oauth2/accessCode. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string AuthorizationUrl { + get { return authorizationUrl_; } + set { + authorizationUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "token_url" field. + public const int TokenUrlFieldNumber = 7; + private string tokenUrl_ = ""; + /// + /// Required. The token URL to be used for this flow. This SHOULD be in the + /// form of a URL. + /// + /// Valid for oauth2/password, oauth2/application and oauth2/accessCode. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string TokenUrl { + get { return tokenUrl_; } + set { + tokenUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "scopes" field. + public const int ScopesFieldNumber = 8; + private global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes scopes_; + /// + /// Required. The available scopes for the OAuth2 security scheme. + /// + /// Valid for oauth2. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes Scopes { + get { return scopes_; } + set { + scopes_ = value; + } + } + + /// Field number for the "extensions" field. + public const int ExtensionsFieldNumber = 9; + private static readonly pbc::MapField.Codec _map_extensions_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Value.Parser), 74); + private readonly pbc::MapField extensions_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Extensions { + get { return extensions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SecurityScheme); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SecurityScheme other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Type != other.Type) return false; + if (Description != other.Description) return false; + if (Name != other.Name) return false; + if (In != other.In) return false; + if (Flow != other.Flow) return false; + if (AuthorizationUrl != other.AuthorizationUrl) return false; + if (TokenUrl != other.TokenUrl) return false; + if (!object.Equals(Scopes, other.Scopes)) return false; + if (!Extensions.Equals(other.Extensions)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Type != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type.Invalid) hash ^= Type.GetHashCode(); + if (Description.Length != 0) hash ^= Description.GetHashCode(); + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (In != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In.Invalid) hash ^= In.GetHashCode(); + if (Flow != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow.Invalid) hash ^= Flow.GetHashCode(); + if (AuthorizationUrl.Length != 0) hash ^= AuthorizationUrl.GetHashCode(); + if (TokenUrl.Length != 0) hash ^= TokenUrl.GetHashCode(); + if (scopes_ != null) hash ^= Scopes.GetHashCode(); + hash ^= Extensions.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Type != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type.Invalid) { + output.WriteRawTag(8); + output.WriteEnum((int) Type); + } + if (Description.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Description); + } + if (Name.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Name); + } + if (In != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In.Invalid) { + output.WriteRawTag(32); + output.WriteEnum((int) In); + } + if (Flow != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow.Invalid) { + output.WriteRawTag(40); + output.WriteEnum((int) Flow); + } + if (AuthorizationUrl.Length != 0) { + output.WriteRawTag(50); + output.WriteString(AuthorizationUrl); + } + if (TokenUrl.Length != 0) { + output.WriteRawTag(58); + output.WriteString(TokenUrl); + } + if (scopes_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Scopes); + } + extensions_.WriteTo(output, _map_extensions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Type != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type.Invalid) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (Description.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (In != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In.Invalid) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) In); + } + if (Flow != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow.Invalid) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Flow); + } + if (AuthorizationUrl.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AuthorizationUrl); + } + if (TokenUrl.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TokenUrl); + } + if (scopes_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Scopes); + } + size += extensions_.CalculateSize(_map_extensions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SecurityScheme other) { + if (other == null) { + return; + } + if (other.Type != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type.Invalid) { + Type = other.Type; + } + if (other.Description.Length != 0) { + Description = other.Description; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.In != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In.Invalid) { + In = other.In; + } + if (other.Flow != global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow.Invalid) { + Flow = other.Flow; + } + if (other.AuthorizationUrl.Length != 0) { + AuthorizationUrl = other.AuthorizationUrl; + } + if (other.TokenUrl.Length != 0) { + TokenUrl = other.TokenUrl; + } + if (other.scopes_ != null) { + if (scopes_ == null) { + Scopes = new global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes(); + } + Scopes.MergeFrom(other.Scopes); + } + extensions_.Add(other.extensions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Type = (global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Type) input.ReadEnum(); + break; + } + case 18: { + Description = input.ReadString(); + break; + } + case 26: { + Name = input.ReadString(); + break; + } + case 32: { + In = (global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.In) input.ReadEnum(); + break; + } + case 40: { + Flow = (global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityScheme.Types.Flow) input.ReadEnum(); + break; + } + case 50: { + AuthorizationUrl = input.ReadString(); + break; + } + case 58: { + TokenUrl = input.ReadString(); + break; + } + case 66: { + if (scopes_ == null) { + Scopes = new global::Grpc.Gateway.ProtocGenSwagger.Options.Scopes(); + } + input.ReadMessage(Scopes); + break; + } + case 74: { + extensions_.AddEntriesFrom(input, _map_extensions_codec); + break; + } + } + } + } + + #region Nested types + /// Container for nested types declared in the SecurityScheme message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// Required. The type of the security scheme. Valid values are "basic", + /// "apiKey" or "oauth2". + /// + internal enum Type { + [pbr::OriginalName("TYPE_INVALID")] Invalid = 0, + [pbr::OriginalName("TYPE_BASIC")] Basic = 1, + [pbr::OriginalName("TYPE_API_KEY")] ApiKey = 2, + [pbr::OriginalName("TYPE_OAUTH2")] Oauth2 = 3, + } + + /// + /// Required. The location of the API key. Valid values are "query" or "header". + /// + internal enum In { + [pbr::OriginalName("IN_INVALID")] Invalid = 0, + [pbr::OriginalName("IN_QUERY")] Query = 1, + [pbr::OriginalName("IN_HEADER")] Header = 2, + } + + /// + /// Required. The flow used by the OAuth2 security scheme. Valid values are + /// "implicit", "password", "application" or "accessCode". + /// + internal enum Flow { + [pbr::OriginalName("FLOW_INVALID")] Invalid = 0, + [pbr::OriginalName("FLOW_IMPLICIT")] Implicit = 1, + [pbr::OriginalName("FLOW_PASSWORD")] Password = 2, + [pbr::OriginalName("FLOW_APPLICATION")] Application = 3, + [pbr::OriginalName("FLOW_ACCESS_CODE")] AccessCode = 4, + } + + } + #endregion + + } + + /// + /// `SecurityRequirement` is a representation of OpenAPI v2 specification's + /// Security Requirement object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityRequirementObject + /// + /// Lists the required security schemes to execute this operation. The object can + /// have multiple security schemes declared in it which are all required (that + /// is, there is a logical AND between the schemes). + /// + /// The name used for each property MUST correspond to a security scheme + /// declared in the Security Definitions. + /// + internal sealed partial class SecurityRequirement : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SecurityRequirement()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirement() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirement(SecurityRequirement other) : this() { + securityRequirement_ = other.securityRequirement_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirement Clone() { + return new SecurityRequirement(this); + } + + /// Field number for the "security_requirement" field. + public const int SecurityRequirement_FieldNumber = 1; + private static readonly pbc::MapField.Codec _map_securityRequirement_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Types.SecurityRequirementValue.Parser), 10); + private readonly pbc::MapField securityRequirement_ = new pbc::MapField(); + /// + /// Each name must correspond to a security scheme which is declared in + /// the Security Definitions. If the security scheme is of type "oauth2", + /// then the value is a list of scope names required for the execution. + /// For other security scheme types, the array MUST be empty. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField SecurityRequirement_ { + get { return securityRequirement_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SecurityRequirement); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SecurityRequirement other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!SecurityRequirement_.Equals(other.SecurityRequirement_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= SecurityRequirement_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + securityRequirement_.WriteTo(output, _map_securityRequirement_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += securityRequirement_.CalculateSize(_map_securityRequirement_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SecurityRequirement other) { + if (other == null) { + return; + } + securityRequirement_.Add(other.securityRequirement_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + securityRequirement_.AddEntriesFrom(input, _map_securityRequirement_codec); + break; + } + } + } + } + + #region Nested types + /// Container for nested types declared in the SecurityRequirement message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// If the security scheme is of type "oauth2", then the value is a list of + /// scope names required for the execution. For other security scheme types, + /// the array MUST be empty. + /// + internal sealed partial class SecurityRequirementValue : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SecurityRequirementValue()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.SecurityRequirement.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirementValue() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirementValue(SecurityRequirementValue other) : this() { + scope_ = other.scope_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SecurityRequirementValue Clone() { + return new SecurityRequirementValue(this); + } + + /// Field number for the "scope" field. + public const int ScopeFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_scope_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField scope_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Scope { + get { return scope_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SecurityRequirementValue); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SecurityRequirementValue other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!scope_.Equals(other.scope_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= scope_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + scope_.WriteTo(output, _repeated_scope_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += scope_.CalculateSize(_repeated_scope_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SecurityRequirementValue other) { + if (other == null) { + return; + } + scope_.Add(other.scope_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + scope_.AddEntriesFrom(input, _repeated_scope_codec); + break; + } + } + } + } + + } + + } + #endregion + + } + + /// + /// `Scopes` is a representation of OpenAPI v2 specification's Scopes object. + /// + /// See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#scopesObject + /// + /// Lists the available scopes for an OAuth2 security scheme. + /// + internal sealed partial class Scopes : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Scopes()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Gateway.ProtocGenSwagger.Options.Openapiv2Reflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Scopes() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Scopes(Scopes other) : this() { + scope_ = other.scope_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Scopes Clone() { + return new Scopes(this); + } + + /// Field number for the "scope" field. + public const int ScopeFieldNumber = 1; + private static readonly pbc::MapField.Codec _map_scope_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 10); + private readonly pbc::MapField scope_ = new pbc::MapField(); + /// + /// Maps between a name of a scope to a short description of it (as the value + /// of the property). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Scope { + get { return scope_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Scopes); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Scopes other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Scope.Equals(other.Scope)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= Scope.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + scope_.WriteTo(output, _map_scope_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += scope_.CalculateSize(_map_scope_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Scopes other) { + if (other == null) { + return; + } + scope_.Add(other.scope_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + scope_.AddEntriesFrom(input, _map_scope_codec); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Jaeger.Communication.Grpc.csproj b/src/Communication/Jaeger.Communication.Grpc/Jaeger.Communication.Grpc.csproj new file mode 100644 index 000000000..140cb36e7 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Jaeger.Communication.Grpc.csproj @@ -0,0 +1,16 @@ + + + + netstandard2.0 + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + diff --git a/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Collector.cs b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Collector.cs new file mode 100644 index 000000000..f8ba45af6 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Collector.cs @@ -0,0 +1,289 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: collector.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Jaeger.ApiV2 { + + /// Holder for reflection information generated from collector.proto + public static partial class CollectorReflection { + + #region Descriptor + /// File descriptor for collector.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static CollectorReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cg9jb2xsZWN0b3IucHJvdG8SDWphZWdlci5hcGlfdjIaC21vZGVsLnByb3Rv", + "GhRnb2dvcHJvdG8vZ29nby5wcm90bxocZ29vZ2xlL2FwaS9hbm5vdGF0aW9u", + "cy5wcm90bxoscHJvdG9jLWdlbi1zd2FnZ2VyL29wdGlvbnMvYW5ub3RhdGlv", + "bnMucHJvdG8iPQoQUG9zdFNwYW5zUmVxdWVzdBIpCgViYXRjaBgBIAEoCzIU", + "LmphZWdlci5hcGlfdjIuQmF0Y2hCBMjeHwAiEwoRUG9zdFNwYW5zUmVzcG9u", + "c2UyfAoQQ29sbGVjdG9yU2VydmljZRJoCglQb3N0U3BhbnMSHy5qYWVnZXIu", + "YXBpX3YyLlBvc3RTcGFuc1JlcXVlc3QaIC5qYWVnZXIuYXBpX3YyLlBvc3RT", + "cGFuc1Jlc3BvbnNlIhiC0+STAhIiDS9hcGkvdjIvc3BhbnM6ASpCdgoXaW8u", + "amFlZ2VydHJhY2luZy5hcGlfdjJaBmFwaV92MsjiHgHQ4h4B4OIeAcDjHgGS", + "QUISBTIDMS4wKgIBAnI1CgpKYWVnZXIgQVBJEidodHRwczovL2dpdGh1Yi5j", + "b20vamFlZ2VydHJhY2luZy9qYWVnZXJiBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Jaeger.ApiV2.ModelReflection.Descriptor, global::Gogoproto.GogoReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Grpc.Gateway.ProtocGenSwagger.Options.AnnotationsReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.PostSpansRequest), global::Jaeger.ApiV2.PostSpansRequest.Parser, new[]{ "Batch" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.PostSpansResponse), global::Jaeger.ApiV2.PostSpansResponse.Parser, null, null, null, null, null) + })); + } + #endregion + + } + #region Messages + public sealed partial class PostSpansRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PostSpansRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.CollectorReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansRequest(PostSpansRequest other) : this() { + batch_ = other.batch_ != null ? other.batch_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansRequest Clone() { + return new PostSpansRequest(this); + } + + /// Field number for the "batch" field. + public const int BatchFieldNumber = 1; + private global::Jaeger.ApiV2.Batch batch_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.Batch Batch { + get { return batch_; } + set { + batch_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as PostSpansRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(PostSpansRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Batch, other.Batch)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (batch_ != null) hash ^= Batch.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (batch_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Batch); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (batch_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Batch); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(PostSpansRequest other) { + if (other == null) { + return; + } + if (other.batch_ != null) { + if (batch_ == null) { + Batch = new global::Jaeger.ApiV2.Batch(); + } + Batch.MergeFrom(other.Batch); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (batch_ == null) { + Batch = new global::Jaeger.ApiV2.Batch(); + } + input.ReadMessage(Batch); + break; + } + } + } + } + + } + + public sealed partial class PostSpansResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PostSpansResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.CollectorReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansResponse(PostSpansResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PostSpansResponse Clone() { + return new PostSpansResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as PostSpansResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(PostSpansResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(PostSpansResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Model.cs b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Model.cs new file mode 100644 index 000000000..5e872f918 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Model.cs @@ -0,0 +1,2010 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: model.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Jaeger.ApiV2 { + + /// Holder for reflection information generated from model.proto + public static partial class ModelReflection { + + #region Descriptor + /// File descriptor for model.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static ModelReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cgttb2RlbC5wcm90bxINamFlZ2VyLmFwaV92MhoUZ29nb3Byb3RvL2dvZ28u", + "cHJvdG8aH2dvb2dsZS9wcm90b2J1Zi90aW1lc3RhbXAucHJvdG8aHmdvb2ds", + "ZS9wcm90b2J1Zi9kdXJhdGlvbi5wcm90byKgAQoIS2V5VmFsdWUSCwoDa2V5", + "GAEgASgJEigKBnZfdHlwZRgCIAEoDjIYLmphZWdlci5hcGlfdjIuVmFsdWVU", + "eXBlEg0KBXZfc3RyGAMgASgJEg4KBnZfYm9vbBgEIAEoCBIPCgd2X2ludDY0", + "GAUgASgDEhEKCXZfZmxvYXQ2NBgGIAEoARIQCgh2X2JpbmFyeRgHIAEoDDoI", + "6KAfAeihHwEibQoDTG9nEjcKCXRpbWVzdGFtcBgBIAEoCzIaLmdvb2dsZS5w", + "cm90b2J1Zi5UaW1lc3RhbXBCCJDfHwHI3h8AEi0KBmZpZWxkcxgCIAMoCzIX", + "LmphZWdlci5hcGlfdjIuS2V5VmFsdWVCBMjeHwAikAEKB1NwYW5SZWYSLAoI", + "dHJhY2VfaWQYASABKAxCGsjeHwDa3h8HVHJhY2VJROLeHwdUcmFjZUlEEikK", + "B3NwYW5faWQYAiABKAxCGMjeHwDa3h8GU3BhbklE4t4fBlNwYW5JRBIsCghy", + "ZWZfdHlwZRgDIAEoDjIaLmphZWdlci5hcGlfdjIuU3BhblJlZlR5cGUiTAoH", + "UHJvY2VzcxIUCgxzZXJ2aWNlX25hbWUYASABKAkSKwoEdGFncxgCIAMoCzIX", + "LmphZWdlci5hcGlfdjIuS2V5VmFsdWVCBMjeHwAi6wMKBFNwYW4SLAoIdHJh", + "Y2VfaWQYASABKAxCGsjeHwDa3h8HVHJhY2VJROLeHwdUcmFjZUlEEikKB3Nw", + "YW5faWQYAiABKAxCGMjeHwDa3h8GU3BhbklE4t4fBlNwYW5JRBIWCg5vcGVy", + "YXRpb25fbmFtZRgDIAEoCRIwCgpyZWZlcmVuY2VzGAQgAygLMhYuamFlZ2Vy", + "LmFwaV92Mi5TcGFuUmVmQgTI3h8AEhwKBWZsYWdzGAUgASgNQg3I3h8A2t4f", + "BUZsYWdzEjgKCnN0YXJ0X3RpbWUYBiABKAsyGi5nb29nbGUucHJvdG9idWYu", + "VGltZXN0YW1wQgiQ3x8ByN4fABI1CghkdXJhdGlvbhgHIAEoCzIZLmdvb2ds", + "ZS5wcm90b2J1Zi5EdXJhdGlvbkIImN8fAcjeHwASKwoEdGFncxgIIAMoCzIX", + "LmphZWdlci5hcGlfdjIuS2V5VmFsdWVCBMjeHwASJgoEbG9ncxgJIAMoCzIS", + "LmphZWdlci5hcGlfdjIuTG9nQgTI3h8AEicKB3Byb2Nlc3MYCiABKAsyFi5q", + "YWVnZXIuYXBpX3YyLlByb2Nlc3MSIQoKcHJvY2Vzc19pZBgLIAEoCUIN4t4f", + "CVByb2Nlc3NJRBIQCgh3YXJuaW5ncxgMIAMoCSLhAQoFVHJhY2USIgoFc3Bh", + "bnMYASADKAsyEy5qYWVnZXIuYXBpX3YyLlNwYW4SPgoLcHJvY2Vzc19tYXAY", + "AiADKAsyIy5qYWVnZXIuYXBpX3YyLlRyYWNlLlByb2Nlc3NNYXBwaW5nQgTI", + "3h8AEhAKCHdhcm5pbmdzGAMgAygJGmIKDlByb2Nlc3NNYXBwaW5nEiEKCnBy", + "b2Nlc3NfaWQYASABKAlCDeLeHwlQcm9jZXNzSUQSLQoHcHJvY2VzcxgCIAEo", + "CzIWLmphZWdlci5hcGlfdjIuUHJvY2Vzc0IEyN4fACJaCgVCYXRjaBIiCgVz", + "cGFucxgBIAMoCzITLmphZWdlci5hcGlfdjIuU3BhbhItCgdwcm9jZXNzGAIg", + "ASgLMhYuamFlZ2VyLmFwaV92Mi5Qcm9jZXNzQgTI3h8BIlMKDkRlcGVuZGVu", + "Y3lMaW5rEg4KBnBhcmVudBgBIAEoCRINCgVjaGlsZBgCIAEoCRISCgpjYWxs", + "X2NvdW50GAMgASgEEg4KBnNvdXJjZRgEIAEoCSpFCglWYWx1ZVR5cGUSCgoG", + "U1RSSU5HEAASCAoEQk9PTBABEgkKBUlOVDY0EAISCwoHRkxPQVQ2NBADEgoK", + "BkJJTkFSWRAEKi0KC1NwYW5SZWZUeXBlEgwKCENISUxEX09GEAASEAoMRk9M", + "TE9XU19GUk9NEAFCMAoXaW8uamFlZ2VydHJhY2luZy5hcGlfdjJaBW1vZGVs", + "yOIeAdDiHgHg4h4BwOMeAWIGcHJvdG8z")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Gogoproto.GogoReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Jaeger.ApiV2.ValueType), typeof(global::Jaeger.ApiV2.SpanRefType), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.KeyValue), global::Jaeger.ApiV2.KeyValue.Parser, new[]{ "Key", "VType", "VStr", "VBool", "VInt64", "VFloat64", "VBinary" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Log), global::Jaeger.ApiV2.Log.Parser, new[]{ "Timestamp", "Fields" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.SpanRef), global::Jaeger.ApiV2.SpanRef.Parser, new[]{ "TraceId", "SpanId", "RefType" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Process), global::Jaeger.ApiV2.Process.Parser, new[]{ "ServiceName", "Tags" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Span), global::Jaeger.ApiV2.Span.Parser, new[]{ "TraceId", "SpanId", "OperationName", "References", "Flags", "StartTime", "Duration", "Tags", "Logs", "Process", "ProcessId", "Warnings" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Trace), global::Jaeger.ApiV2.Trace.Parser, new[]{ "Spans", "ProcessMap", "Warnings" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Trace.Types.ProcessMapping), global::Jaeger.ApiV2.Trace.Types.ProcessMapping.Parser, new[]{ "ProcessId", "Process" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Batch), global::Jaeger.ApiV2.Batch.Parser, new[]{ "Spans", "Process" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.DependencyLink), global::Jaeger.ApiV2.DependencyLink.Parser, new[]{ "Parent", "Child", "CallCount", "Source" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + public enum ValueType { + [pbr::OriginalName("STRING")] String = 0, + [pbr::OriginalName("BOOL")] Bool = 1, + [pbr::OriginalName("INT64")] Int64 = 2, + [pbr::OriginalName("FLOAT64")] Float64 = 3, + [pbr::OriginalName("BINARY")] Binary = 4, + } + + public enum SpanRefType { + [pbr::OriginalName("CHILD_OF")] ChildOf = 0, + [pbr::OriginalName("FOLLOWS_FROM")] FollowsFrom = 1, + } + + #endregion + + #region Messages + public sealed partial class KeyValue : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new KeyValue()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KeyValue() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KeyValue(KeyValue other) : this() { + key_ = other.key_; + vType_ = other.vType_; + vStr_ = other.vStr_; + vBool_ = other.vBool_; + vInt64_ = other.vInt64_; + vFloat64_ = other.vFloat64_; + vBinary_ = other.vBinary_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public KeyValue Clone() { + return new KeyValue(this); + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 1; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "v_type" field. + public const int VTypeFieldNumber = 2; + private global::Jaeger.ApiV2.ValueType vType_ = global::Jaeger.ApiV2.ValueType.String; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.ValueType VType { + get { return vType_; } + set { + vType_ = value; + } + } + + /// Field number for the "v_str" field. + public const int VStrFieldNumber = 3; + private string vStr_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string VStr { + get { return vStr_; } + set { + vStr_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "v_bool" field. + public const int VBoolFieldNumber = 4; + private bool vBool_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool VBool { + get { return vBool_; } + set { + vBool_ = value; + } + } + + /// Field number for the "v_int64" field. + public const int VInt64FieldNumber = 5; + private long vInt64_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public long VInt64 { + get { return vInt64_; } + set { + vInt64_ = value; + } + } + + /// Field number for the "v_float64" field. + public const int VFloat64FieldNumber = 6; + private double vFloat64_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double VFloat64 { + get { return vFloat64_; } + set { + vFloat64_ = value; + } + } + + /// Field number for the "v_binary" field. + public const int VBinaryFieldNumber = 7; + private pb::ByteString vBinary_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString VBinary { + get { return vBinary_; } + set { + vBinary_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as KeyValue); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(KeyValue other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (VType != other.VType) return false; + if (VStr != other.VStr) return false; + if (VBool != other.VBool) return false; + if (VInt64 != other.VInt64) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(VFloat64, other.VFloat64)) return false; + if (VBinary != other.VBinary) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (VType != global::Jaeger.ApiV2.ValueType.String) hash ^= VType.GetHashCode(); + if (VStr.Length != 0) hash ^= VStr.GetHashCode(); + if (VBool != false) hash ^= VBool.GetHashCode(); + if (VInt64 != 0L) hash ^= VInt64.GetHashCode(); + if (VFloat64 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(VFloat64); + if (VBinary.Length != 0) hash ^= VBinary.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (VType != global::Jaeger.ApiV2.ValueType.String) { + output.WriteRawTag(16); + output.WriteEnum((int) VType); + } + if (VStr.Length != 0) { + output.WriteRawTag(26); + output.WriteString(VStr); + } + if (VBool != false) { + output.WriteRawTag(32); + output.WriteBool(VBool); + } + if (VInt64 != 0L) { + output.WriteRawTag(40); + output.WriteInt64(VInt64); + } + if (VFloat64 != 0D) { + output.WriteRawTag(49); + output.WriteDouble(VFloat64); + } + if (VBinary.Length != 0) { + output.WriteRawTag(58); + output.WriteBytes(VBinary); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (VType != global::Jaeger.ApiV2.ValueType.String) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) VType); + } + if (VStr.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(VStr); + } + if (VBool != false) { + size += 1 + 1; + } + if (VInt64 != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(VInt64); + } + if (VFloat64 != 0D) { + size += 1 + 8; + } + if (VBinary.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(VBinary); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(KeyValue other) { + if (other == null) { + return; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.VType != global::Jaeger.ApiV2.ValueType.String) { + VType = other.VType; + } + if (other.VStr.Length != 0) { + VStr = other.VStr; + } + if (other.VBool != false) { + VBool = other.VBool; + } + if (other.VInt64 != 0L) { + VInt64 = other.VInt64; + } + if (other.VFloat64 != 0D) { + VFloat64 = other.VFloat64; + } + if (other.VBinary.Length != 0) { + VBinary = other.VBinary; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Key = input.ReadString(); + break; + } + case 16: { + VType = (global::Jaeger.ApiV2.ValueType) input.ReadEnum(); + break; + } + case 26: { + VStr = input.ReadString(); + break; + } + case 32: { + VBool = input.ReadBool(); + break; + } + case 40: { + VInt64 = input.ReadInt64(); + break; + } + case 49: { + VFloat64 = input.ReadDouble(); + break; + } + case 58: { + VBinary = input.ReadBytes(); + break; + } + } + } + } + + } + + public sealed partial class Log : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Log()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Log() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Log(Log other) : this() { + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + fields_ = other.fields_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Log Clone() { + return new Log(this); + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "fields" field. + public const int FieldsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_fields_codec + = pb::FieldCodec.ForMessage(18, global::Jaeger.ApiV2.KeyValue.Parser); + private readonly pbc::RepeatedField fields_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Fields { + get { return fields_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Log); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Log other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if(!fields_.Equals(other.fields_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + hash ^= fields_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (timestamp_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Timestamp); + } + fields_.WriteTo(output, _repeated_fields_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + size += fields_.CalculateSize(_repeated_fields_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Log other) { + if (other == null) { + return; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + fields_.Add(other.fields_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 18: { + fields_.AddEntriesFrom(input, _repeated_fields_codec); + break; + } + } + } + } + + } + + public sealed partial class SpanRef : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SpanRef()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpanRef() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpanRef(SpanRef other) : this() { + traceId_ = other.traceId_; + spanId_ = other.spanId_; + refType_ = other.refType_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpanRef Clone() { + return new SpanRef(this); + } + + /// Field number for the "trace_id" field. + public const int TraceIdFieldNumber = 1; + private pb::ByteString traceId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString TraceId { + get { return traceId_; } + set { + traceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "span_id" field. + public const int SpanIdFieldNumber = 2; + private pb::ByteString spanId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString SpanId { + get { return spanId_; } + set { + spanId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "ref_type" field. + public const int RefTypeFieldNumber = 3; + private global::Jaeger.ApiV2.SpanRefType refType_ = global::Jaeger.ApiV2.SpanRefType.ChildOf; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.SpanRefType RefType { + get { return refType_; } + set { + refType_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SpanRef); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SpanRef other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TraceId != other.TraceId) return false; + if (SpanId != other.SpanId) return false; + if (RefType != other.RefType) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (TraceId.Length != 0) hash ^= TraceId.GetHashCode(); + if (SpanId.Length != 0) hash ^= SpanId.GetHashCode(); + if (RefType != global::Jaeger.ApiV2.SpanRefType.ChildOf) hash ^= RefType.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (TraceId.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(TraceId); + } + if (SpanId.Length != 0) { + output.WriteRawTag(18); + output.WriteBytes(SpanId); + } + if (RefType != global::Jaeger.ApiV2.SpanRefType.ChildOf) { + output.WriteRawTag(24); + output.WriteEnum((int) RefType); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (TraceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(TraceId); + } + if (SpanId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(SpanId); + } + if (RefType != global::Jaeger.ApiV2.SpanRefType.ChildOf) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) RefType); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SpanRef other) { + if (other == null) { + return; + } + if (other.TraceId.Length != 0) { + TraceId = other.TraceId; + } + if (other.SpanId.Length != 0) { + SpanId = other.SpanId; + } + if (other.RefType != global::Jaeger.ApiV2.SpanRefType.ChildOf) { + RefType = other.RefType; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TraceId = input.ReadBytes(); + break; + } + case 18: { + SpanId = input.ReadBytes(); + break; + } + case 24: { + RefType = (global::Jaeger.ApiV2.SpanRefType) input.ReadEnum(); + break; + } + } + } + } + + } + + public sealed partial class Process : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Process()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Process() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Process(Process other) : this() { + serviceName_ = other.serviceName_; + tags_ = other.tags_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Process Clone() { + return new Process(this); + } + + /// Field number for the "service_name" field. + public const int ServiceNameFieldNumber = 1; + private string serviceName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ServiceName { + get { return serviceName_; } + set { + serviceName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tags" field. + public const int TagsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_tags_codec + = pb::FieldCodec.ForMessage(18, global::Jaeger.ApiV2.KeyValue.Parser); + private readonly pbc::RepeatedField tags_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Tags { + get { return tags_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Process); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Process other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ServiceName != other.ServiceName) return false; + if(!tags_.Equals(other.tags_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (ServiceName.Length != 0) hash ^= ServiceName.GetHashCode(); + hash ^= tags_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (ServiceName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ServiceName); + } + tags_.WriteTo(output, _repeated_tags_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (ServiceName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceName); + } + size += tags_.CalculateSize(_repeated_tags_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Process other) { + if (other == null) { + return; + } + if (other.ServiceName.Length != 0) { + ServiceName = other.ServiceName; + } + tags_.Add(other.tags_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ServiceName = input.ReadString(); + break; + } + case 18: { + tags_.AddEntriesFrom(input, _repeated_tags_codec); + break; + } + } + } + } + + } + + public sealed partial class Span : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Span()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Span() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Span(Span other) : this() { + traceId_ = other.traceId_; + spanId_ = other.spanId_; + operationName_ = other.operationName_; + references_ = other.references_.Clone(); + flags_ = other.flags_; + startTime_ = other.startTime_ != null ? other.startTime_.Clone() : null; + duration_ = other.duration_ != null ? other.duration_.Clone() : null; + tags_ = other.tags_.Clone(); + logs_ = other.logs_.Clone(); + process_ = other.process_ != null ? other.process_.Clone() : null; + processId_ = other.processId_; + warnings_ = other.warnings_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Span Clone() { + return new Span(this); + } + + /// Field number for the "trace_id" field. + public const int TraceIdFieldNumber = 1; + private pb::ByteString traceId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString TraceId { + get { return traceId_; } + set { + traceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "span_id" field. + public const int SpanIdFieldNumber = 2; + private pb::ByteString spanId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString SpanId { + get { return spanId_; } + set { + spanId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "operation_name" field. + public const int OperationNameFieldNumber = 3; + private string operationName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string OperationName { + get { return operationName_; } + set { + operationName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "references" field. + public const int ReferencesFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_references_codec + = pb::FieldCodec.ForMessage(34, global::Jaeger.ApiV2.SpanRef.Parser); + private readonly pbc::RepeatedField references_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField References { + get { return references_; } + } + + /// Field number for the "flags" field. + public const int FlagsFieldNumber = 5; + private uint flags_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public uint Flags { + get { return flags_; } + set { + flags_ = value; + } + } + + /// Field number for the "start_time" field. + public const int StartTimeFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTime_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTime { + get { return startTime_; } + set { + startTime_ = value; + } + } + + /// Field number for the "duration" field. + public const int DurationFieldNumber = 7; + private global::Google.Protobuf.WellKnownTypes.Duration duration_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Duration Duration { + get { return duration_; } + set { + duration_ = value; + } + } + + /// Field number for the "tags" field. + public const int TagsFieldNumber = 8; + private static readonly pb::FieldCodec _repeated_tags_codec + = pb::FieldCodec.ForMessage(66, global::Jaeger.ApiV2.KeyValue.Parser); + private readonly pbc::RepeatedField tags_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Tags { + get { return tags_; } + } + + /// Field number for the "logs" field. + public const int LogsFieldNumber = 9; + private static readonly pb::FieldCodec _repeated_logs_codec + = pb::FieldCodec.ForMessage(74, global::Jaeger.ApiV2.Log.Parser); + private readonly pbc::RepeatedField logs_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Logs { + get { return logs_; } + } + + /// Field number for the "process" field. + public const int ProcessFieldNumber = 10; + private global::Jaeger.ApiV2.Process process_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.Process Process { + get { return process_; } + set { + process_ = value; + } + } + + /// Field number for the "process_id" field. + public const int ProcessIdFieldNumber = 11; + private string processId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ProcessId { + get { return processId_; } + set { + processId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "warnings" field. + public const int WarningsFieldNumber = 12; + private static readonly pb::FieldCodec _repeated_warnings_codec + = pb::FieldCodec.ForString(98); + private readonly pbc::RepeatedField warnings_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Warnings { + get { return warnings_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Span); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Span other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TraceId != other.TraceId) return false; + if (SpanId != other.SpanId) return false; + if (OperationName != other.OperationName) return false; + if(!references_.Equals(other.references_)) return false; + if (Flags != other.Flags) return false; + if (!object.Equals(StartTime, other.StartTime)) return false; + if (!object.Equals(Duration, other.Duration)) return false; + if(!tags_.Equals(other.tags_)) return false; + if(!logs_.Equals(other.logs_)) return false; + if (!object.Equals(Process, other.Process)) return false; + if (ProcessId != other.ProcessId) return false; + if(!warnings_.Equals(other.warnings_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (TraceId.Length != 0) hash ^= TraceId.GetHashCode(); + if (SpanId.Length != 0) hash ^= SpanId.GetHashCode(); + if (OperationName.Length != 0) hash ^= OperationName.GetHashCode(); + hash ^= references_.GetHashCode(); + if (Flags != 0) hash ^= Flags.GetHashCode(); + if (startTime_ != null) hash ^= StartTime.GetHashCode(); + if (duration_ != null) hash ^= Duration.GetHashCode(); + hash ^= tags_.GetHashCode(); + hash ^= logs_.GetHashCode(); + if (process_ != null) hash ^= Process.GetHashCode(); + if (ProcessId.Length != 0) hash ^= ProcessId.GetHashCode(); + hash ^= warnings_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (TraceId.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(TraceId); + } + if (SpanId.Length != 0) { + output.WriteRawTag(18); + output.WriteBytes(SpanId); + } + if (OperationName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(OperationName); + } + references_.WriteTo(output, _repeated_references_codec); + if (Flags != 0) { + output.WriteRawTag(40); + output.WriteUInt32(Flags); + } + if (startTime_ != null) { + output.WriteRawTag(50); + output.WriteMessage(StartTime); + } + if (duration_ != null) { + output.WriteRawTag(58); + output.WriteMessage(Duration); + } + tags_.WriteTo(output, _repeated_tags_codec); + logs_.WriteTo(output, _repeated_logs_codec); + if (process_ != null) { + output.WriteRawTag(82); + output.WriteMessage(Process); + } + if (ProcessId.Length != 0) { + output.WriteRawTag(90); + output.WriteString(ProcessId); + } + warnings_.WriteTo(output, _repeated_warnings_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (TraceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(TraceId); + } + if (SpanId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(SpanId); + } + if (OperationName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OperationName); + } + size += references_.CalculateSize(_repeated_references_codec); + if (Flags != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Flags); + } + if (startTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTime); + } + if (duration_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Duration); + } + size += tags_.CalculateSize(_repeated_tags_codec); + size += logs_.CalculateSize(_repeated_logs_codec); + if (process_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Process); + } + if (ProcessId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProcessId); + } + size += warnings_.CalculateSize(_repeated_warnings_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Span other) { + if (other == null) { + return; + } + if (other.TraceId.Length != 0) { + TraceId = other.TraceId; + } + if (other.SpanId.Length != 0) { + SpanId = other.SpanId; + } + if (other.OperationName.Length != 0) { + OperationName = other.OperationName; + } + references_.Add(other.references_); + if (other.Flags != 0) { + Flags = other.Flags; + } + if (other.startTime_ != null) { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTime.MergeFrom(other.StartTime); + } + if (other.duration_ != null) { + if (duration_ == null) { + Duration = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + Duration.MergeFrom(other.Duration); + } + tags_.Add(other.tags_); + logs_.Add(other.logs_); + if (other.process_ != null) { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + Process.MergeFrom(other.Process); + } + if (other.ProcessId.Length != 0) { + ProcessId = other.ProcessId; + } + warnings_.Add(other.warnings_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TraceId = input.ReadBytes(); + break; + } + case 18: { + SpanId = input.ReadBytes(); + break; + } + case 26: { + OperationName = input.ReadString(); + break; + } + case 34: { + references_.AddEntriesFrom(input, _repeated_references_codec); + break; + } + case 40: { + Flags = input.ReadUInt32(); + break; + } + case 50: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 58: { + if (duration_ == null) { + Duration = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(Duration); + break; + } + case 66: { + tags_.AddEntriesFrom(input, _repeated_tags_codec); + break; + } + case 74: { + logs_.AddEntriesFrom(input, _repeated_logs_codec); + break; + } + case 82: { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + input.ReadMessage(Process); + break; + } + case 90: { + ProcessId = input.ReadString(); + break; + } + case 98: { + warnings_.AddEntriesFrom(input, _repeated_warnings_codec); + break; + } + } + } + } + + } + + public sealed partial class Trace : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Trace()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Trace() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Trace(Trace other) : this() { + spans_ = other.spans_.Clone(); + processMap_ = other.processMap_.Clone(); + warnings_ = other.warnings_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Trace Clone() { + return new Trace(this); + } + + /// Field number for the "spans" field. + public const int SpansFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spans_codec + = pb::FieldCodec.ForMessage(10, global::Jaeger.ApiV2.Span.Parser); + private readonly pbc::RepeatedField spans_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Spans { + get { return spans_; } + } + + /// Field number for the "process_map" field. + public const int ProcessMapFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_processMap_codec + = pb::FieldCodec.ForMessage(18, global::Jaeger.ApiV2.Trace.Types.ProcessMapping.Parser); + private readonly pbc::RepeatedField processMap_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField ProcessMap { + get { return processMap_; } + } + + /// Field number for the "warnings" field. + public const int WarningsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_warnings_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField warnings_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Warnings { + get { return warnings_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Trace); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Trace other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!spans_.Equals(other.spans_)) return false; + if(!processMap_.Equals(other.processMap_)) return false; + if(!warnings_.Equals(other.warnings_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= spans_.GetHashCode(); + hash ^= processMap_.GetHashCode(); + hash ^= warnings_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + spans_.WriteTo(output, _repeated_spans_codec); + processMap_.WriteTo(output, _repeated_processMap_codec); + warnings_.WriteTo(output, _repeated_warnings_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += spans_.CalculateSize(_repeated_spans_codec); + size += processMap_.CalculateSize(_repeated_processMap_codec); + size += warnings_.CalculateSize(_repeated_warnings_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Trace other) { + if (other == null) { + return; + } + spans_.Add(other.spans_); + processMap_.Add(other.processMap_); + warnings_.Add(other.warnings_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + spans_.AddEntriesFrom(input, _repeated_spans_codec); + break; + } + case 18: { + processMap_.AddEntriesFrom(input, _repeated_processMap_codec); + break; + } + case 26: { + warnings_.AddEntriesFrom(input, _repeated_warnings_codec); + break; + } + } + } + } + + #region Nested types + /// Container for nested types declared in the Trace message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + public sealed partial class ProcessMapping : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ProcessMapping()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.Trace.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProcessMapping() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProcessMapping(ProcessMapping other) : this() { + processId_ = other.processId_; + process_ = other.process_ != null ? other.process_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProcessMapping Clone() { + return new ProcessMapping(this); + } + + /// Field number for the "process_id" field. + public const int ProcessIdFieldNumber = 1; + private string processId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ProcessId { + get { return processId_; } + set { + processId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "process" field. + public const int ProcessFieldNumber = 2; + private global::Jaeger.ApiV2.Process process_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.Process Process { + get { return process_; } + set { + process_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ProcessMapping); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ProcessMapping other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ProcessId != other.ProcessId) return false; + if (!object.Equals(Process, other.Process)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (ProcessId.Length != 0) hash ^= ProcessId.GetHashCode(); + if (process_ != null) hash ^= Process.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (ProcessId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ProcessId); + } + if (process_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Process); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (ProcessId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ProcessId); + } + if (process_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Process); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ProcessMapping other) { + if (other == null) { + return; + } + if (other.ProcessId.Length != 0) { + ProcessId = other.ProcessId; + } + if (other.process_ != null) { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + Process.MergeFrom(other.Process); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ProcessId = input.ReadString(); + break; + } + case 18: { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + input.ReadMessage(Process); + break; + } + } + } + } + + } + + } + #endregion + + } + + public sealed partial class Batch : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Batch()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Batch() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Batch(Batch other) : this() { + spans_ = other.spans_.Clone(); + process_ = other.process_ != null ? other.process_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Batch Clone() { + return new Batch(this); + } + + /// Field number for the "spans" field. + public const int SpansFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spans_codec + = pb::FieldCodec.ForMessage(10, global::Jaeger.ApiV2.Span.Parser); + private readonly pbc::RepeatedField spans_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Spans { + get { return spans_; } + } + + /// Field number for the "process" field. + public const int ProcessFieldNumber = 2; + private global::Jaeger.ApiV2.Process process_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.Process Process { + get { return process_; } + set { + process_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Batch); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Batch other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!spans_.Equals(other.spans_)) return false; + if (!object.Equals(Process, other.Process)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= spans_.GetHashCode(); + if (process_ != null) hash ^= Process.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + spans_.WriteTo(output, _repeated_spans_codec); + if (process_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Process); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += spans_.CalculateSize(_repeated_spans_codec); + if (process_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Process); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Batch other) { + if (other == null) { + return; + } + spans_.Add(other.spans_); + if (other.process_ != null) { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + Process.MergeFrom(other.Process); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + spans_.AddEntriesFrom(input, _repeated_spans_codec); + break; + } + case 18: { + if (process_ == null) { + Process = new global::Jaeger.ApiV2.Process(); + } + input.ReadMessage(Process); + break; + } + } + } + } + + } + + public sealed partial class DependencyLink : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DependencyLink()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.ModelReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DependencyLink() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DependencyLink(DependencyLink other) : this() { + parent_ = other.parent_; + child_ = other.child_; + callCount_ = other.callCount_; + source_ = other.source_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public DependencyLink Clone() { + return new DependencyLink(this); + } + + /// Field number for the "parent" field. + public const int ParentFieldNumber = 1; + private string parent_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Parent { + get { return parent_; } + set { + parent_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "child" field. + public const int ChildFieldNumber = 2; + private string child_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Child { + get { return child_; } + set { + child_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "call_count" field. + public const int CallCountFieldNumber = 3; + private ulong callCount_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong CallCount { + get { return callCount_; } + set { + callCount_ = value; + } + } + + /// Field number for the "source" field. + public const int SourceFieldNumber = 4; + private string source_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Source { + get { return source_; } + set { + source_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as DependencyLink); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(DependencyLink other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Parent != other.Parent) return false; + if (Child != other.Child) return false; + if (CallCount != other.CallCount) return false; + if (Source != other.Source) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Parent.Length != 0) hash ^= Parent.GetHashCode(); + if (Child.Length != 0) hash ^= Child.GetHashCode(); + if (CallCount != 0UL) hash ^= CallCount.GetHashCode(); + if (Source.Length != 0) hash ^= Source.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Parent.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Parent); + } + if (Child.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Child); + } + if (CallCount != 0UL) { + output.WriteRawTag(24); + output.WriteUInt64(CallCount); + } + if (Source.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Source); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Parent.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Parent); + } + if (Child.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Child); + } + if (CallCount != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(CallCount); + } + if (Source.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Source); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(DependencyLink other) { + if (other == null) { + return; + } + if (other.Parent.Length != 0) { + Parent = other.Parent; + } + if (other.Child.Length != 0) { + Child = other.Child; + } + if (other.CallCount != 0UL) { + CallCount = other.CallCount; + } + if (other.Source.Length != 0) { + Source = other.Source; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Parent = input.ReadString(); + break; + } + case 18: { + Child = input.ReadString(); + break; + } + case 24: { + CallCount = input.ReadUInt64(); + break; + } + case 34: { + Source = input.ReadString(); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Query.cs b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Query.cs new file mode 100644 index 000000000..fd58174a6 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Query.cs @@ -0,0 +1,2031 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: query.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Jaeger.ApiV2 { + + /// Holder for reflection information generated from query.proto + public static partial class QueryReflection { + + #region Descriptor + /// File descriptor for query.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static QueryReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "CgtxdWVyeS5wcm90bxINamFlZ2VyLmFwaV92MhoLbW9kZWwucHJvdG8aFGdv", + "Z29wcm90by9nb2dvLnByb3RvGhxnb29nbGUvYXBpL2Fubm90YXRpb25zLnBy", + "b3RvGh9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvGh5nb29nbGUv", + "cHJvdG9idWYvZHVyYXRpb24ucHJvdG8aLHByb3RvYy1nZW4tc3dhZ2dlci9v", + "cHRpb25zL2Fubm90YXRpb25zLnByb3RvImUKD0dldFRyYWNlUmVxdWVzdBJS", + "Cgh0cmFjZV9pZBgBIAEoDEJAyN4fANreHy1naXRodWIuY29tL2phZWdlcnRy", + "YWNpbmcvamFlZ2VyL21vZGVsLlRyYWNlSUTi3h8HVHJhY2VJRCI+ChJTcGFu", + "c1Jlc3BvbnNlQ2h1bmsSKAoFc3BhbnMYASADKAsyEy5qYWVnZXIuYXBpX3Yy", + "LlNwYW5CBMjeHwAiaQoTQXJjaGl2ZVRyYWNlUmVxdWVzdBJSCgh0cmFjZV9p", + "ZBgBIAEoDEJAyN4fANreHy1naXRodWIuY29tL2phZWdlcnRyYWNpbmcvamFl", + "Z2VyL21vZGVsLlRyYWNlSUTi3h8HVHJhY2VJRCIWChRBcmNoaXZlVHJhY2VS", + "ZXNwb25zZSK2AwoUVHJhY2VRdWVyeVBhcmFtZXRlcnMSFAoMc2VydmljZV9u", + "YW1lGAEgASgJEhYKDm9wZXJhdGlvbl9uYW1lGAIgASgJEjsKBHRhZ3MYAyAD", + "KAsyLS5qYWVnZXIuYXBpX3YyLlRyYWNlUXVlcnlQYXJhbWV0ZXJzLlRhZ3NF", + "bnRyeRI8Cg5zdGFydF90aW1lX21pbhgEIAEoCzIaLmdvb2dsZS5wcm90b2J1", + "Zi5UaW1lc3RhbXBCCJDfHwHI3h8AEjwKDnN0YXJ0X3RpbWVfbWF4GAUgASgL", + "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEIIkN8fAcjeHwASOQoMZHVy", + "YXRpb25fbWluGAYgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uQgiY", + "3x8ByN4fABI5CgxkdXJhdGlvbl9tYXgYByABKAsyGS5nb29nbGUucHJvdG9i", + "dWYuRHVyYXRpb25CCJjfHwHI3h8AEhQKDHNlYXJjaF9kZXB0aBgIIAEoBRor", + "CglUYWdzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ASJH", + "ChFGaW5kVHJhY2VzUmVxdWVzdBIyCgVxdWVyeRgBIAEoCzIjLmphZWdlci5h", + "cGlfdjIuVHJhY2VRdWVyeVBhcmFtZXRlcnMiFAoSR2V0U2VydmljZXNSZXF1", + "ZXN0IicKE0dldFNlcnZpY2VzUmVzcG9uc2USEAoIc2VydmljZXMYASADKAki", + "OgoUR2V0T3BlcmF0aW9uc1JlcXVlc3QSDwoHc2VydmljZRgBIAEoCRIRCglz", + "cGFuX2tpbmQYAiABKAkiLAoJT3BlcmF0aW9uEgwKBG5hbWUYASABKAkSEQoJ", + "c3Bhbl9raW5kGAIgASgJIl0KFUdldE9wZXJhdGlvbnNSZXNwb25zZRIWCg5v", + "cGVyYXRpb25OYW1lcxgBIAMoCRIsCgpvcGVyYXRpb25zGAIgAygLMhguamFl", + "Z2VyLmFwaV92Mi5PcGVyYXRpb24iigEKFkdldERlcGVuZGVuY2llc1JlcXVl", + "c3QSOAoKc3RhcnRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l", + "c3RhbXBCCJDfHwHI3h8AEjYKCGVuZF90aW1lGAIgASgLMhouZ29vZ2xlLnBy", + "b3RvYnVmLlRpbWVzdGFtcEIIkN8fAcjeHwAiVAoXR2V0RGVwZW5kZW5jaWVz", + "UmVzcG9uc2USOQoMZGVwZW5kZW5jaWVzGAEgAygLMh0uamFlZ2VyLmFwaV92", + "Mi5EZXBlbmRlbmN5TGlua0IEyN4fADKtBQoMUXVlcnlTZXJ2aWNlEmsKCEdl", + "dFRyYWNlEh4uamFlZ2VyLmFwaV92Mi5HZXRUcmFjZVJlcXVlc3QaIS5qYWVn", + "ZXIuYXBpX3YyLlNwYW5zUmVzcG9uc2VDaHVuayIagtPkkwIUEhIvdHJhY2Vz", + "L3t0cmFjZV9pZH0wARJ0CgxBcmNoaXZlVHJhY2USIi5qYWVnZXIuYXBpX3Yy", + "LkFyY2hpdmVUcmFjZVJlcXVlc3QaIy5qYWVnZXIuYXBpX3YyLkFyY2hpdmVU", + "cmFjZVJlc3BvbnNlIhuC0+STAhUiEy9hcmNoaXZlL3t0cmFjZV9pZH0SZwoK", + "RmluZFRyYWNlcxIgLmphZWdlci5hcGlfdjIuRmluZFRyYWNlc1JlcXVlc3Qa", + "IS5qYWVnZXIuYXBpX3YyLlNwYW5zUmVzcG9uc2VDaHVuayISgtPkkwIMIgcv", + "c2VhcmNoOgEqMAESZwoLR2V0U2VydmljZXMSIS5qYWVnZXIuYXBpX3YyLkdl", + "dFNlcnZpY2VzUmVxdWVzdBoiLmphZWdlci5hcGlfdjIuR2V0U2VydmljZXNS", + "ZXNwb25zZSIRgtPkkwILEgkvc2VydmljZXMSbwoNR2V0T3BlcmF0aW9ucxIj", + "LmphZWdlci5hcGlfdjIuR2V0T3BlcmF0aW9uc1JlcXVlc3QaJC5qYWVnZXIu", + "YXBpX3YyLkdldE9wZXJhdGlvbnNSZXNwb25zZSITgtPkkwINEgsvb3BlcmF0", + "aW9ucxJ3Cg9HZXREZXBlbmRlbmNpZXMSJS5qYWVnZXIuYXBpX3YyLkdldERl", + "cGVuZGVuY2llc1JlcXVlc3QaJi5qYWVnZXIuYXBpX3YyLkdldERlcGVuZGVu", + "Y2llc1Jlc3BvbnNlIhWC0+STAg8SDS9kZXBlbmRlbmNpZXNCdgoXaW8uamFl", + "Z2VydHJhY2luZy5hcGlfdjJaBmFwaV92MsjiHgHQ4h4B4OIeAcDjHgGSQUIS", + "BTIDMS4wKgIBAnI1CgpKYWVnZXIgQVBJEidodHRwczovL2dpdGh1Yi5jb20v", + "amFlZ2VydHJhY2luZy9qYWVnZXJiBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Jaeger.ApiV2.ModelReflection.Descriptor, global::Gogoproto.GogoReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Grpc.Gateway.ProtocGenSwagger.Options.AnnotationsReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetTraceRequest), global::Jaeger.ApiV2.GetTraceRequest.Parser, new[]{ "TraceId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.SpansResponseChunk), global::Jaeger.ApiV2.SpansResponseChunk.Parser, new[]{ "Spans" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.ArchiveTraceRequest), global::Jaeger.ApiV2.ArchiveTraceRequest.Parser, new[]{ "TraceId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.ArchiveTraceResponse), global::Jaeger.ApiV2.ArchiveTraceResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.TraceQueryParameters), global::Jaeger.ApiV2.TraceQueryParameters.Parser, new[]{ "ServiceName", "OperationName", "Tags", "StartTimeMin", "StartTimeMax", "DurationMin", "DurationMax", "SearchDepth" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.FindTracesRequest), global::Jaeger.ApiV2.FindTracesRequest.Parser, new[]{ "Query" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetServicesRequest), global::Jaeger.ApiV2.GetServicesRequest.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetServicesResponse), global::Jaeger.ApiV2.GetServicesResponse.Parser, new[]{ "Services" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetOperationsRequest), global::Jaeger.ApiV2.GetOperationsRequest.Parser, new[]{ "Service", "SpanKind" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.Operation), global::Jaeger.ApiV2.Operation.Parser, new[]{ "Name", "SpanKind" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetOperationsResponse), global::Jaeger.ApiV2.GetOperationsResponse.Parser, new[]{ "OperationNames", "Operations" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetDependenciesRequest), global::Jaeger.ApiV2.GetDependenciesRequest.Parser, new[]{ "StartTime", "EndTime" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.GetDependenciesResponse), global::Jaeger.ApiV2.GetDependenciesResponse.Parser, new[]{ "Dependencies" }, null, null, null, null) + })); + } + #endregion + + } + #region Messages + public sealed partial class GetTraceRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetTraceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetTraceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetTraceRequest(GetTraceRequest other) : this() { + traceId_ = other.traceId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetTraceRequest Clone() { + return new GetTraceRequest(this); + } + + /// Field number for the "trace_id" field. + public const int TraceIdFieldNumber = 1; + private pb::ByteString traceId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString TraceId { + get { return traceId_; } + set { + traceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetTraceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetTraceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TraceId != other.TraceId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (TraceId.Length != 0) hash ^= TraceId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (TraceId.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(TraceId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (TraceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(TraceId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetTraceRequest other) { + if (other == null) { + return; + } + if (other.TraceId.Length != 0) { + TraceId = other.TraceId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TraceId = input.ReadBytes(); + break; + } + } + } + } + + } + + public sealed partial class SpansResponseChunk : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SpansResponseChunk()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpansResponseChunk() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpansResponseChunk(SpansResponseChunk other) : this() { + spans_ = other.spans_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SpansResponseChunk Clone() { + return new SpansResponseChunk(this); + } + + /// Field number for the "spans" field. + public const int SpansFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_spans_codec + = pb::FieldCodec.ForMessage(10, global::Jaeger.ApiV2.Span.Parser); + private readonly pbc::RepeatedField spans_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Spans { + get { return spans_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SpansResponseChunk); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SpansResponseChunk other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!spans_.Equals(other.spans_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= spans_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + spans_.WriteTo(output, _repeated_spans_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += spans_.CalculateSize(_repeated_spans_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SpansResponseChunk other) { + if (other == null) { + return; + } + spans_.Add(other.spans_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + spans_.AddEntriesFrom(input, _repeated_spans_codec); + break; + } + } + } + } + + } + + public sealed partial class ArchiveTraceRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ArchiveTraceRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceRequest(ArchiveTraceRequest other) : this() { + traceId_ = other.traceId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceRequest Clone() { + return new ArchiveTraceRequest(this); + } + + /// Field number for the "trace_id" field. + public const int TraceIdFieldNumber = 1; + private pb::ByteString traceId_ = pb::ByteString.Empty; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString TraceId { + get { return traceId_; } + set { + traceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ArchiveTraceRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ArchiveTraceRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TraceId != other.TraceId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (TraceId.Length != 0) hash ^= TraceId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (TraceId.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(TraceId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (TraceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(TraceId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ArchiveTraceRequest other) { + if (other == null) { + return; + } + if (other.TraceId.Length != 0) { + TraceId = other.TraceId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TraceId = input.ReadBytes(); + break; + } + } + } + } + + } + + public sealed partial class ArchiveTraceResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ArchiveTraceResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceResponse(ArchiveTraceResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ArchiveTraceResponse Clone() { + return new ArchiveTraceResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ArchiveTraceResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ArchiveTraceResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ArchiveTraceResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + } + + } + + public sealed partial class TraceQueryParameters : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TraceQueryParameters()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public TraceQueryParameters() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public TraceQueryParameters(TraceQueryParameters other) : this() { + serviceName_ = other.serviceName_; + operationName_ = other.operationName_; + tags_ = other.tags_.Clone(); + startTimeMin_ = other.startTimeMin_ != null ? other.startTimeMin_.Clone() : null; + startTimeMax_ = other.startTimeMax_ != null ? other.startTimeMax_.Clone() : null; + durationMin_ = other.durationMin_ != null ? other.durationMin_.Clone() : null; + durationMax_ = other.durationMax_ != null ? other.durationMax_.Clone() : null; + searchDepth_ = other.searchDepth_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public TraceQueryParameters Clone() { + return new TraceQueryParameters(this); + } + + /// Field number for the "service_name" field. + public const int ServiceNameFieldNumber = 1; + private string serviceName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ServiceName { + get { return serviceName_; } + set { + serviceName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "operation_name" field. + public const int OperationNameFieldNumber = 2; + private string operationName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string OperationName { + get { return operationName_; } + set { + operationName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tags" field. + public const int TagsFieldNumber = 3; + private static readonly pbc::MapField.Codec _map_tags_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 26); + private readonly pbc::MapField tags_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField Tags { + get { return tags_; } + } + + /// Field number for the "start_time_min" field. + public const int StartTimeMinFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTimeMin_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTimeMin { + get { return startTimeMin_; } + set { + startTimeMin_ = value; + } + } + + /// Field number for the "start_time_max" field. + public const int StartTimeMaxFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTimeMax_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTimeMax { + get { return startTimeMax_; } + set { + startTimeMax_ = value; + } + } + + /// Field number for the "duration_min" field. + public const int DurationMinFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Duration durationMin_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Duration DurationMin { + get { return durationMin_; } + set { + durationMin_ = value; + } + } + + /// Field number for the "duration_max" field. + public const int DurationMaxFieldNumber = 7; + private global::Google.Protobuf.WellKnownTypes.Duration durationMax_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Duration DurationMax { + get { return durationMax_; } + set { + durationMax_ = value; + } + } + + /// Field number for the "search_depth" field. + public const int SearchDepthFieldNumber = 8; + private int searchDepth_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int SearchDepth { + get { return searchDepth_; } + set { + searchDepth_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as TraceQueryParameters); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(TraceQueryParameters other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ServiceName != other.ServiceName) return false; + if (OperationName != other.OperationName) return false; + if (!Tags.Equals(other.Tags)) return false; + if (!object.Equals(StartTimeMin, other.StartTimeMin)) return false; + if (!object.Equals(StartTimeMax, other.StartTimeMax)) return false; + if (!object.Equals(DurationMin, other.DurationMin)) return false; + if (!object.Equals(DurationMax, other.DurationMax)) return false; + if (SearchDepth != other.SearchDepth) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (ServiceName.Length != 0) hash ^= ServiceName.GetHashCode(); + if (OperationName.Length != 0) hash ^= OperationName.GetHashCode(); + hash ^= Tags.GetHashCode(); + if (startTimeMin_ != null) hash ^= StartTimeMin.GetHashCode(); + if (startTimeMax_ != null) hash ^= StartTimeMax.GetHashCode(); + if (durationMin_ != null) hash ^= DurationMin.GetHashCode(); + if (durationMax_ != null) hash ^= DurationMax.GetHashCode(); + if (SearchDepth != 0) hash ^= SearchDepth.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (ServiceName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ServiceName); + } + if (OperationName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(OperationName); + } + tags_.WriteTo(output, _map_tags_codec); + if (startTimeMin_ != null) { + output.WriteRawTag(34); + output.WriteMessage(StartTimeMin); + } + if (startTimeMax_ != null) { + output.WriteRawTag(42); + output.WriteMessage(StartTimeMax); + } + if (durationMin_ != null) { + output.WriteRawTag(50); + output.WriteMessage(DurationMin); + } + if (durationMax_ != null) { + output.WriteRawTag(58); + output.WriteMessage(DurationMax); + } + if (SearchDepth != 0) { + output.WriteRawTag(64); + output.WriteInt32(SearchDepth); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (ServiceName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceName); + } + if (OperationName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OperationName); + } + size += tags_.CalculateSize(_map_tags_codec); + if (startTimeMin_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTimeMin); + } + if (startTimeMax_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTimeMax); + } + if (durationMin_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DurationMin); + } + if (durationMax_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DurationMax); + } + if (SearchDepth != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(SearchDepth); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(TraceQueryParameters other) { + if (other == null) { + return; + } + if (other.ServiceName.Length != 0) { + ServiceName = other.ServiceName; + } + if (other.OperationName.Length != 0) { + OperationName = other.OperationName; + } + tags_.Add(other.tags_); + if (other.startTimeMin_ != null) { + if (startTimeMin_ == null) { + StartTimeMin = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTimeMin.MergeFrom(other.StartTimeMin); + } + if (other.startTimeMax_ != null) { + if (startTimeMax_ == null) { + StartTimeMax = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTimeMax.MergeFrom(other.StartTimeMax); + } + if (other.durationMin_ != null) { + if (durationMin_ == null) { + DurationMin = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + DurationMin.MergeFrom(other.DurationMin); + } + if (other.durationMax_ != null) { + if (durationMax_ == null) { + DurationMax = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + DurationMax.MergeFrom(other.DurationMax); + } + if (other.SearchDepth != 0) { + SearchDepth = other.SearchDepth; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ServiceName = input.ReadString(); + break; + } + case 18: { + OperationName = input.ReadString(); + break; + } + case 26: { + tags_.AddEntriesFrom(input, _map_tags_codec); + break; + } + case 34: { + if (startTimeMin_ == null) { + StartTimeMin = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTimeMin); + break; + } + case 42: { + if (startTimeMax_ == null) { + StartTimeMax = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTimeMax); + break; + } + case 50: { + if (durationMin_ == null) { + DurationMin = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(DurationMin); + break; + } + case 58: { + if (durationMax_ == null) { + DurationMax = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(DurationMax); + break; + } + case 64: { + SearchDepth = input.ReadInt32(); + break; + } + } + } + } + + } + + public sealed partial class FindTracesRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FindTracesRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FindTracesRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FindTracesRequest(FindTracesRequest other) : this() { + query_ = other.query_ != null ? other.query_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public FindTracesRequest Clone() { + return new FindTracesRequest(this); + } + + /// Field number for the "query" field. + public const int QueryFieldNumber = 1; + private global::Jaeger.ApiV2.TraceQueryParameters query_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.TraceQueryParameters Query { + get { return query_; } + set { + query_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as FindTracesRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(FindTracesRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Query, other.Query)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (query_ != null) hash ^= Query.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (query_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Query); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (query_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Query); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(FindTracesRequest other) { + if (other == null) { + return; + } + if (other.query_ != null) { + if (query_ == null) { + Query = new global::Jaeger.ApiV2.TraceQueryParameters(); + } + Query.MergeFrom(other.Query); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (query_ == null) { + Query = new global::Jaeger.ApiV2.TraceQueryParameters(); + } + input.ReadMessage(Query); + break; + } + } + } + } + + } + + public sealed partial class GetServicesRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetServicesRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesRequest(GetServicesRequest other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesRequest Clone() { + return new GetServicesRequest(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetServicesRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetServicesRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetServicesRequest other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + } + + } + + public sealed partial class GetServicesResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetServicesResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesResponse(GetServicesResponse other) : this() { + services_ = other.services_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetServicesResponse Clone() { + return new GetServicesResponse(this); + } + + /// Field number for the "services" field. + public const int ServicesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_services_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField services_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Services { + get { return services_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetServicesResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetServicesResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!services_.Equals(other.services_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= services_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + services_.WriteTo(output, _repeated_services_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += services_.CalculateSize(_repeated_services_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetServicesResponse other) { + if (other == null) { + return; + } + services_.Add(other.services_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + services_.AddEntriesFrom(input, _repeated_services_codec); + break; + } + } + } + } + + } + + public sealed partial class GetOperationsRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetOperationsRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsRequest(GetOperationsRequest other) : this() { + service_ = other.service_; + spanKind_ = other.spanKind_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsRequest Clone() { + return new GetOperationsRequest(this); + } + + /// Field number for the "service" field. + public const int ServiceFieldNumber = 1; + private string service_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Service { + get { return service_; } + set { + service_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "span_kind" field. + public const int SpanKindFieldNumber = 2; + private string spanKind_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string SpanKind { + get { return spanKind_; } + set { + spanKind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetOperationsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetOperationsRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Service != other.Service) return false; + if (SpanKind != other.SpanKind) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Service.Length != 0) hash ^= Service.GetHashCode(); + if (SpanKind.Length != 0) hash ^= SpanKind.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Service.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Service); + } + if (SpanKind.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpanKind); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Service.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Service); + } + if (SpanKind.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SpanKind); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetOperationsRequest other) { + if (other == null) { + return; + } + if (other.Service.Length != 0) { + Service = other.Service; + } + if (other.SpanKind.Length != 0) { + SpanKind = other.SpanKind; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Service = input.ReadString(); + break; + } + case 18: { + SpanKind = input.ReadString(); + break; + } + } + } + } + + } + + public sealed partial class Operation : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Operation()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation(Operation other) : this() { + name_ = other.name_; + spanKind_ = other.spanKind_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Operation Clone() { + return new Operation(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "span_kind" field. + public const int SpanKindFieldNumber = 2; + private string spanKind_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string SpanKind { + get { return spanKind_; } + set { + spanKind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Operation); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Operation other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (SpanKind != other.SpanKind) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (SpanKind.Length != 0) hash ^= SpanKind.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (SpanKind.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SpanKind); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (SpanKind.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SpanKind); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Operation other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.SpanKind.Length != 0) { + SpanKind = other.SpanKind; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + SpanKind = input.ReadString(); + break; + } + } + } + } + + } + + public sealed partial class GetOperationsResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetOperationsResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsResponse(GetOperationsResponse other) : this() { + operationNames_ = other.operationNames_.Clone(); + operations_ = other.operations_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetOperationsResponse Clone() { + return new GetOperationsResponse(this); + } + + /// Field number for the "operationNames" field. + public const int OperationNamesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_operationNames_codec + = pb::FieldCodec.ForString(10); + private readonly pbc::RepeatedField operationNames_ = new pbc::RepeatedField(); + /// + ///deprecated + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField OperationNames { + get { return operationNames_; } + } + + /// Field number for the "operations" field. + public const int OperationsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_operations_codec + = pb::FieldCodec.ForMessage(18, global::Jaeger.ApiV2.Operation.Parser); + private readonly pbc::RepeatedField operations_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Operations { + get { return operations_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetOperationsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetOperationsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!operationNames_.Equals(other.operationNames_)) return false; + if(!operations_.Equals(other.operations_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= operationNames_.GetHashCode(); + hash ^= operations_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + operationNames_.WriteTo(output, _repeated_operationNames_codec); + operations_.WriteTo(output, _repeated_operations_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += operationNames_.CalculateSize(_repeated_operationNames_codec); + size += operations_.CalculateSize(_repeated_operations_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetOperationsResponse other) { + if (other == null) { + return; + } + operationNames_.Add(other.operationNames_); + operations_.Add(other.operations_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + operationNames_.AddEntriesFrom(input, _repeated_operationNames_codec); + break; + } + case 18: { + operations_.AddEntriesFrom(input, _repeated_operations_codec); + break; + } + } + } + } + + } + + public sealed partial class GetDependenciesRequest : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetDependenciesRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesRequest(GetDependenciesRequest other) : this() { + startTime_ = other.startTime_ != null ? other.startTime_.Clone() : null; + endTime_ = other.endTime_ != null ? other.endTime_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesRequest Clone() { + return new GetDependenciesRequest(this); + } + + /// Field number for the "start_time" field. + public const int StartTimeFieldNumber = 1; + private global::Google.Protobuf.WellKnownTypes.Timestamp startTime_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp StartTime { + get { return startTime_; } + set { + startTime_ = value; + } + } + + /// Field number for the "end_time" field. + public const int EndTimeFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp endTime_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Google.Protobuf.WellKnownTypes.Timestamp EndTime { + get { return endTime_; } + set { + endTime_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetDependenciesRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetDependenciesRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(StartTime, other.StartTime)) return false; + if (!object.Equals(EndTime, other.EndTime)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (startTime_ != null) hash ^= StartTime.GetHashCode(); + if (endTime_ != null) hash ^= EndTime.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (startTime_ != null) { + output.WriteRawTag(10); + output.WriteMessage(StartTime); + } + if (endTime_ != null) { + output.WriteRawTag(18); + output.WriteMessage(EndTime); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (startTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(StartTime); + } + if (endTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EndTime); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetDependenciesRequest other) { + if (other == null) { + return; + } + if (other.startTime_ != null) { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + StartTime.MergeFrom(other.StartTime); + } + if (other.endTime_ != null) { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + EndTime.MergeFrom(other.EndTime); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (startTime_ == null) { + StartTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(StartTime); + break; + } + case 18: { + if (endTime_ == null) { + EndTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(EndTime); + break; + } + } + } + } + + } + + public sealed partial class GetDependenciesResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new GetDependenciesResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesResponse(GetDependenciesResponse other) : this() { + dependencies_ = other.dependencies_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public GetDependenciesResponse Clone() { + return new GetDependenciesResponse(this); + } + + /// Field number for the "dependencies" field. + public const int DependenciesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_dependencies_codec + = pb::FieldCodec.ForMessage(10, global::Jaeger.ApiV2.DependencyLink.Parser); + private readonly pbc::RepeatedField dependencies_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Dependencies { + get { return dependencies_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as GetDependenciesResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(GetDependenciesResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!dependencies_.Equals(other.dependencies_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= dependencies_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + dependencies_.WriteTo(output, _repeated_dependencies_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += dependencies_.CalculateSize(_repeated_dependencies_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(GetDependenciesResponse other) { + if (other == null) { + return; + } + dependencies_.Add(other.dependencies_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + dependencies_.AddEntriesFrom(input, _repeated_dependencies_codec); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Sampling.cs b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Sampling.cs new file mode 100644 index 000000000..7979c367b --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/Jaeger/ApiV2/Sampling.cs @@ -0,0 +1,1070 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: sampling.proto +// +#pragma warning disable 1591, 0612, 3021 +#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 Jaeger.ApiV2 { + + /// Holder for reflection information generated from sampling.proto + public static partial class SamplingReflection { + + #region Descriptor + /// File descriptor for sampling.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static SamplingReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cg5zYW1wbGluZy5wcm90bxINamFlZ2VyLmFwaV92MhoUZ29nb3Byb3RvL2dv", + "Z28ucHJvdG8aHGdvb2dsZS9hcGkvYW5ub3RhdGlvbnMucHJvdG8aLHByb3Rv", + "Yy1nZW4tc3dhZ2dlci9vcHRpb25zL2Fubm90YXRpb25zLnByb3RvIjUKHVBy", + "b2JhYmlsaXN0aWNTYW1wbGluZ1N0cmF0ZWd5EhQKDHNhbXBsaW5nUmF0ZRgB", + "IAEoASI6ChxSYXRlTGltaXRpbmdTYW1wbGluZ1N0cmF0ZWd5EhoKEm1heFRy", + "YWNlc1BlclNlY29uZBgBIAEoBSJ7ChlPcGVyYXRpb25TYW1wbGluZ1N0cmF0", + "ZWd5EhEKCW9wZXJhdGlvbhgBIAEoCRJLChVwcm9iYWJpbGlzdGljU2FtcGxp", + "bmcYAiABKAsyLC5qYWVnZXIuYXBpX3YyLlByb2JhYmlsaXN0aWNTYW1wbGlu", + "Z1N0cmF0ZWd5IuIBCh5QZXJPcGVyYXRpb25TYW1wbGluZ1N0cmF0ZWdpZXMS", + "IgoaZGVmYXVsdFNhbXBsaW5nUHJvYmFiaWxpdHkYASABKAESKAogZGVmYXVs", + "dExvd2VyQm91bmRUcmFjZXNQZXJTZWNvbmQYAiABKAESSAoWcGVyT3BlcmF0", + "aW9uU3RyYXRlZ2llcxgDIAMoCzIoLmphZWdlci5hcGlfdjIuT3BlcmF0aW9u", + "U2FtcGxpbmdTdHJhdGVneRIoCiBkZWZhdWx0VXBwZXJCb3VuZFRyYWNlc1Bl", + "clNlY29uZBgEIAEoASK3AgoYU2FtcGxpbmdTdHJhdGVneVJlc3BvbnNlEjkK", + "DHN0cmF0ZWd5VHlwZRgBIAEoDjIjLmphZWdlci5hcGlfdjIuU2FtcGxpbmdT", + "dHJhdGVneVR5cGUSSwoVcHJvYmFiaWxpc3RpY1NhbXBsaW5nGAIgASgLMiwu", + "amFlZ2VyLmFwaV92Mi5Qcm9iYWJpbGlzdGljU2FtcGxpbmdTdHJhdGVneRJJ", + "ChRyYXRlTGltaXRpbmdTYW1wbGluZxgDIAEoCzIrLmphZWdlci5hcGlfdjIu", + "UmF0ZUxpbWl0aW5nU2FtcGxpbmdTdHJhdGVneRJIChFvcGVyYXRpb25TYW1w", + "bGluZxgEIAEoCzItLmphZWdlci5hcGlfdjIuUGVyT3BlcmF0aW9uU2FtcGxp", + "bmdTdHJhdGVnaWVzIjEKGlNhbXBsaW5nU3RyYXRlZ3lQYXJhbWV0ZXJzEhMK", + "C3NlcnZpY2VOYW1lGAEgASgJKjwKFFNhbXBsaW5nU3RyYXRlZ3lUeXBlEhEK", + "DVBST0JBQklMSVNUSUMQABIRCg1SQVRFX0xJTUlUSU5HEAEyogEKD1NhbXBs", + "aW5nTWFuYWdlchKOAQoTR2V0U2FtcGxpbmdTdHJhdGVneRIpLmphZWdlci5h", + "cGlfdjIuU2FtcGxpbmdTdHJhdGVneVBhcmFtZXRlcnMaJy5qYWVnZXIuYXBp", + "X3YyLlNhbXBsaW5nU3RyYXRlZ3lSZXNwb25zZSIjgtPkkwIdIhgvYXBpL3Yy", + "L3NhbXBsaW5nU3RyYXRlZ3k6ASpCdgoXaW8uamFlZ2VydHJhY2luZy5hcGlf", + "djJaBmFwaV92MsjiHgHQ4h4B4OIeAcDjHgGSQUISBTIDMS4wKgIBAnI1CgpK", + "YWVnZXIgQVBJEidodHRwczovL2dpdGh1Yi5jb20vamFlZ2VydHJhY2luZy9q", + "YWVnZXJiBnByb3RvMw==")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Gogoproto.GogoReflection.Descriptor, global::Google.Api.AnnotationsReflection.Descriptor, global::Grpc.Gateway.ProtocGenSwagger.Options.AnnotationsReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Jaeger.ApiV2.SamplingStrategyType), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.ProbabilisticSamplingStrategy), global::Jaeger.ApiV2.ProbabilisticSamplingStrategy.Parser, new[]{ "SamplingRate" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.RateLimitingSamplingStrategy), global::Jaeger.ApiV2.RateLimitingSamplingStrategy.Parser, new[]{ "MaxTracesPerSecond" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.OperationSamplingStrategy), global::Jaeger.ApiV2.OperationSamplingStrategy.Parser, new[]{ "Operation", "ProbabilisticSampling" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.PerOperationSamplingStrategies), global::Jaeger.ApiV2.PerOperationSamplingStrategies.Parser, new[]{ "DefaultSamplingProbability", "DefaultLowerBoundTracesPerSecond", "PerOperationStrategies", "DefaultUpperBoundTracesPerSecond" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.SamplingStrategyResponse), global::Jaeger.ApiV2.SamplingStrategyResponse.Parser, new[]{ "StrategyType", "ProbabilisticSampling", "RateLimitingSampling", "OperationSampling" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Jaeger.ApiV2.SamplingStrategyParameters), global::Jaeger.ApiV2.SamplingStrategyParameters.Parser, new[]{ "ServiceName" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + public enum SamplingStrategyType { + [pbr::OriginalName("PROBABILISTIC")] Probabilistic = 0, + [pbr::OriginalName("RATE_LIMITING")] RateLimiting = 1, + } + + #endregion + + #region Messages + public sealed partial class ProbabilisticSamplingStrategy : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ProbabilisticSamplingStrategy()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProbabilisticSamplingStrategy() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProbabilisticSamplingStrategy(ProbabilisticSamplingStrategy other) : this() { + samplingRate_ = other.samplingRate_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ProbabilisticSamplingStrategy Clone() { + return new ProbabilisticSamplingStrategy(this); + } + + /// Field number for the "samplingRate" field. + public const int SamplingRateFieldNumber = 1; + private double samplingRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double SamplingRate { + get { return samplingRate_; } + set { + samplingRate_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ProbabilisticSamplingStrategy); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ProbabilisticSamplingStrategy other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SamplingRate, other.SamplingRate)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (SamplingRate != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SamplingRate); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (SamplingRate != 0D) { + output.WriteRawTag(9); + output.WriteDouble(SamplingRate); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (SamplingRate != 0D) { + size += 1 + 8; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ProbabilisticSamplingStrategy other) { + if (other == null) { + return; + } + if (other.SamplingRate != 0D) { + SamplingRate = other.SamplingRate; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 9: { + SamplingRate = input.ReadDouble(); + break; + } + } + } + } + + } + + public sealed partial class RateLimitingSamplingStrategy : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RateLimitingSamplingStrategy()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public RateLimitingSamplingStrategy() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public RateLimitingSamplingStrategy(RateLimitingSamplingStrategy other) : this() { + maxTracesPerSecond_ = other.maxTracesPerSecond_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public RateLimitingSamplingStrategy Clone() { + return new RateLimitingSamplingStrategy(this); + } + + /// Field number for the "maxTracesPerSecond" field. + public const int MaxTracesPerSecondFieldNumber = 1; + private int maxTracesPerSecond_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int MaxTracesPerSecond { + get { return maxTracesPerSecond_; } + set { + maxTracesPerSecond_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as RateLimitingSamplingStrategy); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(RateLimitingSamplingStrategy other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (MaxTracesPerSecond != other.MaxTracesPerSecond) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (MaxTracesPerSecond != 0) hash ^= MaxTracesPerSecond.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (MaxTracesPerSecond != 0) { + output.WriteRawTag(8); + output.WriteInt32(MaxTracesPerSecond); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (MaxTracesPerSecond != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxTracesPerSecond); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(RateLimitingSamplingStrategy other) { + if (other == null) { + return; + } + if (other.MaxTracesPerSecond != 0) { + MaxTracesPerSecond = other.MaxTracesPerSecond; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + MaxTracesPerSecond = input.ReadInt32(); + break; + } + } + } + } + + } + + public sealed partial class OperationSamplingStrategy : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OperationSamplingStrategy()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public OperationSamplingStrategy() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public OperationSamplingStrategy(OperationSamplingStrategy other) : this() { + operation_ = other.operation_; + probabilisticSampling_ = other.probabilisticSampling_ != null ? other.probabilisticSampling_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public OperationSamplingStrategy Clone() { + return new OperationSamplingStrategy(this); + } + + /// Field number for the "operation" field. + public const int OperationFieldNumber = 1; + private string operation_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Operation { + get { return operation_; } + set { + operation_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "probabilisticSampling" field. + public const int ProbabilisticSamplingFieldNumber = 2; + private global::Jaeger.ApiV2.ProbabilisticSamplingStrategy probabilisticSampling_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.ProbabilisticSamplingStrategy ProbabilisticSampling { + get { return probabilisticSampling_; } + set { + probabilisticSampling_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as OperationSamplingStrategy); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(OperationSamplingStrategy other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Operation != other.Operation) return false; + if (!object.Equals(ProbabilisticSampling, other.ProbabilisticSampling)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Operation.Length != 0) hash ^= Operation.GetHashCode(); + if (probabilisticSampling_ != null) hash ^= ProbabilisticSampling.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (Operation.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Operation); + } + if (probabilisticSampling_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ProbabilisticSampling); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Operation.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Operation); + } + if (probabilisticSampling_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ProbabilisticSampling); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(OperationSamplingStrategy other) { + if (other == null) { + return; + } + if (other.Operation.Length != 0) { + Operation = other.Operation; + } + if (other.probabilisticSampling_ != null) { + if (probabilisticSampling_ == null) { + ProbabilisticSampling = new global::Jaeger.ApiV2.ProbabilisticSamplingStrategy(); + } + ProbabilisticSampling.MergeFrom(other.ProbabilisticSampling); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Operation = input.ReadString(); + break; + } + case 18: { + if (probabilisticSampling_ == null) { + ProbabilisticSampling = new global::Jaeger.ApiV2.ProbabilisticSamplingStrategy(); + } + input.ReadMessage(ProbabilisticSampling); + break; + } + } + } + } + + } + + public sealed partial class PerOperationSamplingStrategies : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PerOperationSamplingStrategies()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PerOperationSamplingStrategies() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PerOperationSamplingStrategies(PerOperationSamplingStrategies other) : this() { + defaultSamplingProbability_ = other.defaultSamplingProbability_; + defaultLowerBoundTracesPerSecond_ = other.defaultLowerBoundTracesPerSecond_; + perOperationStrategies_ = other.perOperationStrategies_.Clone(); + defaultUpperBoundTracesPerSecond_ = other.defaultUpperBoundTracesPerSecond_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public PerOperationSamplingStrategies Clone() { + return new PerOperationSamplingStrategies(this); + } + + /// Field number for the "defaultSamplingProbability" field. + public const int DefaultSamplingProbabilityFieldNumber = 1; + private double defaultSamplingProbability_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DefaultSamplingProbability { + get { return defaultSamplingProbability_; } + set { + defaultSamplingProbability_ = value; + } + } + + /// Field number for the "defaultLowerBoundTracesPerSecond" field. + public const int DefaultLowerBoundTracesPerSecondFieldNumber = 2; + private double defaultLowerBoundTracesPerSecond_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DefaultLowerBoundTracesPerSecond { + get { return defaultLowerBoundTracesPerSecond_; } + set { + defaultLowerBoundTracesPerSecond_ = value; + } + } + + /// Field number for the "perOperationStrategies" field. + public const int PerOperationStrategiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_perOperationStrategies_codec + = pb::FieldCodec.ForMessage(26, global::Jaeger.ApiV2.OperationSamplingStrategy.Parser); + private readonly pbc::RepeatedField perOperationStrategies_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PerOperationStrategies { + get { return perOperationStrategies_; } + } + + /// Field number for the "defaultUpperBoundTracesPerSecond" field. + public const int DefaultUpperBoundTracesPerSecondFieldNumber = 4; + private double defaultUpperBoundTracesPerSecond_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public double DefaultUpperBoundTracesPerSecond { + get { return defaultUpperBoundTracesPerSecond_; } + set { + defaultUpperBoundTracesPerSecond_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as PerOperationSamplingStrategies); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(PerOperationSamplingStrategies other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DefaultSamplingProbability, other.DefaultSamplingProbability)) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DefaultLowerBoundTracesPerSecond, other.DefaultLowerBoundTracesPerSecond)) return false; + if(!perOperationStrategies_.Equals(other.perOperationStrategies_)) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DefaultUpperBoundTracesPerSecond, other.DefaultUpperBoundTracesPerSecond)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (DefaultSamplingProbability != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DefaultSamplingProbability); + if (DefaultLowerBoundTracesPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DefaultLowerBoundTracesPerSecond); + hash ^= perOperationStrategies_.GetHashCode(); + if (DefaultUpperBoundTracesPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DefaultUpperBoundTracesPerSecond); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (DefaultSamplingProbability != 0D) { + output.WriteRawTag(9); + output.WriteDouble(DefaultSamplingProbability); + } + if (DefaultLowerBoundTracesPerSecond != 0D) { + output.WriteRawTag(17); + output.WriteDouble(DefaultLowerBoundTracesPerSecond); + } + perOperationStrategies_.WriteTo(output, _repeated_perOperationStrategies_codec); + if (DefaultUpperBoundTracesPerSecond != 0D) { + output.WriteRawTag(33); + output.WriteDouble(DefaultUpperBoundTracesPerSecond); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (DefaultSamplingProbability != 0D) { + size += 1 + 8; + } + if (DefaultLowerBoundTracesPerSecond != 0D) { + size += 1 + 8; + } + size += perOperationStrategies_.CalculateSize(_repeated_perOperationStrategies_codec); + if (DefaultUpperBoundTracesPerSecond != 0D) { + size += 1 + 8; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(PerOperationSamplingStrategies other) { + if (other == null) { + return; + } + if (other.DefaultSamplingProbability != 0D) { + DefaultSamplingProbability = other.DefaultSamplingProbability; + } + if (other.DefaultLowerBoundTracesPerSecond != 0D) { + DefaultLowerBoundTracesPerSecond = other.DefaultLowerBoundTracesPerSecond; + } + perOperationStrategies_.Add(other.perOperationStrategies_); + if (other.DefaultUpperBoundTracesPerSecond != 0D) { + DefaultUpperBoundTracesPerSecond = other.DefaultUpperBoundTracesPerSecond; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 9: { + DefaultSamplingProbability = input.ReadDouble(); + break; + } + case 17: { + DefaultLowerBoundTracesPerSecond = input.ReadDouble(); + break; + } + case 26: { + perOperationStrategies_.AddEntriesFrom(input, _repeated_perOperationStrategies_codec); + break; + } + case 33: { + DefaultUpperBoundTracesPerSecond = input.ReadDouble(); + break; + } + } + } + } + + } + + public sealed partial class SamplingStrategyResponse : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SamplingStrategyResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyResponse(SamplingStrategyResponse other) : this() { + strategyType_ = other.strategyType_; + probabilisticSampling_ = other.probabilisticSampling_ != null ? other.probabilisticSampling_.Clone() : null; + rateLimitingSampling_ = other.rateLimitingSampling_ != null ? other.rateLimitingSampling_.Clone() : null; + operationSampling_ = other.operationSampling_ != null ? other.operationSampling_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyResponse Clone() { + return new SamplingStrategyResponse(this); + } + + /// Field number for the "strategyType" field. + public const int StrategyTypeFieldNumber = 1; + private global::Jaeger.ApiV2.SamplingStrategyType strategyType_ = global::Jaeger.ApiV2.SamplingStrategyType.Probabilistic; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.SamplingStrategyType StrategyType { + get { return strategyType_; } + set { + strategyType_ = value; + } + } + + /// Field number for the "probabilisticSampling" field. + public const int ProbabilisticSamplingFieldNumber = 2; + private global::Jaeger.ApiV2.ProbabilisticSamplingStrategy probabilisticSampling_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.ProbabilisticSamplingStrategy ProbabilisticSampling { + get { return probabilisticSampling_; } + set { + probabilisticSampling_ = value; + } + } + + /// Field number for the "rateLimitingSampling" field. + public const int RateLimitingSamplingFieldNumber = 3; + private global::Jaeger.ApiV2.RateLimitingSamplingStrategy rateLimitingSampling_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.RateLimitingSamplingStrategy RateLimitingSampling { + get { return rateLimitingSampling_; } + set { + rateLimitingSampling_ = value; + } + } + + /// Field number for the "operationSampling" field. + public const int OperationSamplingFieldNumber = 4; + private global::Jaeger.ApiV2.PerOperationSamplingStrategies operationSampling_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Jaeger.ApiV2.PerOperationSamplingStrategies OperationSampling { + get { return operationSampling_; } + set { + operationSampling_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SamplingStrategyResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SamplingStrategyResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StrategyType != other.StrategyType) return false; + if (!object.Equals(ProbabilisticSampling, other.ProbabilisticSampling)) return false; + if (!object.Equals(RateLimitingSampling, other.RateLimitingSampling)) return false; + if (!object.Equals(OperationSampling, other.OperationSampling)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (StrategyType != global::Jaeger.ApiV2.SamplingStrategyType.Probabilistic) hash ^= StrategyType.GetHashCode(); + if (probabilisticSampling_ != null) hash ^= ProbabilisticSampling.GetHashCode(); + if (rateLimitingSampling_ != null) hash ^= RateLimitingSampling.GetHashCode(); + if (operationSampling_ != null) hash ^= OperationSampling.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (StrategyType != global::Jaeger.ApiV2.SamplingStrategyType.Probabilistic) { + output.WriteRawTag(8); + output.WriteEnum((int) StrategyType); + } + if (probabilisticSampling_ != null) { + output.WriteRawTag(18); + output.WriteMessage(ProbabilisticSampling); + } + if (rateLimitingSampling_ != null) { + output.WriteRawTag(26); + output.WriteMessage(RateLimitingSampling); + } + if (operationSampling_ != null) { + output.WriteRawTag(34); + output.WriteMessage(OperationSampling); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (StrategyType != global::Jaeger.ApiV2.SamplingStrategyType.Probabilistic) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) StrategyType); + } + if (probabilisticSampling_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ProbabilisticSampling); + } + if (rateLimitingSampling_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RateLimitingSampling); + } + if (operationSampling_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(OperationSampling); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SamplingStrategyResponse other) { + if (other == null) { + return; + } + if (other.StrategyType != global::Jaeger.ApiV2.SamplingStrategyType.Probabilistic) { + StrategyType = other.StrategyType; + } + if (other.probabilisticSampling_ != null) { + if (probabilisticSampling_ == null) { + ProbabilisticSampling = new global::Jaeger.ApiV2.ProbabilisticSamplingStrategy(); + } + ProbabilisticSampling.MergeFrom(other.ProbabilisticSampling); + } + if (other.rateLimitingSampling_ != null) { + if (rateLimitingSampling_ == null) { + RateLimitingSampling = new global::Jaeger.ApiV2.RateLimitingSamplingStrategy(); + } + RateLimitingSampling.MergeFrom(other.RateLimitingSampling); + } + if (other.operationSampling_ != null) { + if (operationSampling_ == null) { + OperationSampling = new global::Jaeger.ApiV2.PerOperationSamplingStrategies(); + } + OperationSampling.MergeFrom(other.OperationSampling); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + StrategyType = (global::Jaeger.ApiV2.SamplingStrategyType) input.ReadEnum(); + break; + } + case 18: { + if (probabilisticSampling_ == null) { + ProbabilisticSampling = new global::Jaeger.ApiV2.ProbabilisticSamplingStrategy(); + } + input.ReadMessage(ProbabilisticSampling); + break; + } + case 26: { + if (rateLimitingSampling_ == null) { + RateLimitingSampling = new global::Jaeger.ApiV2.RateLimitingSamplingStrategy(); + } + input.ReadMessage(RateLimitingSampling); + break; + } + case 34: { + if (operationSampling_ == null) { + OperationSampling = new global::Jaeger.ApiV2.PerOperationSamplingStrategies(); + } + input.ReadMessage(OperationSampling); + break; + } + } + } + } + + } + + public sealed partial class SamplingStrategyParameters : pb::IMessage { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SamplingStrategyParameters()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyParameters() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyParameters(SamplingStrategyParameters other) : this() { + serviceName_ = other.serviceName_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public SamplingStrategyParameters Clone() { + return new SamplingStrategyParameters(this); + } + + /// Field number for the "serviceName" field. + public const int ServiceNameFieldNumber = 1; + private string serviceName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string ServiceName { + get { return serviceName_; } + set { + serviceName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as SamplingStrategyParameters); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(SamplingStrategyParameters other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ServiceName != other.ServiceName) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (ServiceName.Length != 0) hash ^= ServiceName.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + if (ServiceName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ServiceName); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (ServiceName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceName); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(SamplingStrategyParameters other) { + if (other == null) { + return; + } + if (other.ServiceName.Length != 0) { + ServiceName = other.ServiceName; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ServiceName = input.ReadString(); + break; + } + } + } + } + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/Communication/Jaeger.Communication.Grpc/QueryGrpc.cs b/src/Communication/Jaeger.Communication.Grpc/QueryGrpc.cs new file mode 100644 index 000000000..6307297c6 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/QueryGrpc.cs @@ -0,0 +1,266 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: query.proto +// +// Original file comments: +// Copyright (c) 2019 The Jaeger Authors. +// Copyright (c) 2018 Uber Technologies, Inc. +// +// 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 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Jaeger.ApiV2 { + public static partial class QueryService + { + static readonly string __ServiceName = "jaeger.api_v2.QueryService"; + + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetTraceRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetTraceRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_SpansResponseChunk = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.SpansResponseChunk.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_ArchiveTraceRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.ArchiveTraceRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_ArchiveTraceResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.ArchiveTraceResponse.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_FindTracesRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.FindTracesRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetServicesRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetServicesRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetServicesResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetServicesResponse.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetOperationsRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetOperationsRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetOperationsResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetOperationsResponse.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetDependenciesRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetDependenciesRequest.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_GetDependenciesResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.GetDependenciesResponse.Parser.ParseFrom); + + static readonly grpc::Method __Method_GetTrace = new grpc::Method( + grpc::MethodType.ServerStreaming, + __ServiceName, + "GetTrace", + __Marshaller_jaeger_api_v2_GetTraceRequest, + __Marshaller_jaeger_api_v2_SpansResponseChunk); + + static readonly grpc::Method __Method_ArchiveTrace = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ArchiveTrace", + __Marshaller_jaeger_api_v2_ArchiveTraceRequest, + __Marshaller_jaeger_api_v2_ArchiveTraceResponse); + + static readonly grpc::Method __Method_FindTraces = new grpc::Method( + grpc::MethodType.ServerStreaming, + __ServiceName, + "FindTraces", + __Marshaller_jaeger_api_v2_FindTracesRequest, + __Marshaller_jaeger_api_v2_SpansResponseChunk); + + static readonly grpc::Method __Method_GetServices = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetServices", + __Marshaller_jaeger_api_v2_GetServicesRequest, + __Marshaller_jaeger_api_v2_GetServicesResponse); + + static readonly grpc::Method __Method_GetOperations = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetOperations", + __Marshaller_jaeger_api_v2_GetOperationsRequest, + __Marshaller_jaeger_api_v2_GetOperationsResponse); + + static readonly grpc::Method __Method_GetDependencies = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetDependencies", + __Marshaller_jaeger_api_v2_GetDependenciesRequest, + __Marshaller_jaeger_api_v2_GetDependenciesResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Jaeger.ApiV2.QueryReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of QueryService + [grpc::BindServiceMethod(typeof(QueryService), "BindService")] + public abstract partial class QueryServiceBase + { + public virtual global::System.Threading.Tasks.Task GetTrace(global::Jaeger.ApiV2.GetTraceRequest request, grpc::IServerStreamWriter responseStream, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + public virtual global::System.Threading.Tasks.Task ArchiveTrace(global::Jaeger.ApiV2.ArchiveTraceRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + public virtual global::System.Threading.Tasks.Task FindTraces(global::Jaeger.ApiV2.FindTracesRequest request, grpc::IServerStreamWriter responseStream, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + public virtual global::System.Threading.Tasks.Task GetServices(global::Jaeger.ApiV2.GetServicesRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + public virtual global::System.Threading.Tasks.Task GetOperations(global::Jaeger.ApiV2.GetOperationsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + public virtual global::System.Threading.Tasks.Task GetDependencies(global::Jaeger.ApiV2.GetDependenciesRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for QueryService + public partial class QueryServiceClient : grpc::ClientBase + { + /// Creates a new client for QueryService + /// The channel to use to make remote calls. + public QueryServiceClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for QueryService that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + public QueryServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + protected QueryServiceClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + protected QueryServiceClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + public virtual grpc::AsyncServerStreamingCall GetTrace(global::Jaeger.ApiV2.GetTraceRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetTrace(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncServerStreamingCall GetTrace(global::Jaeger.ApiV2.GetTraceRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncServerStreamingCall(__Method_GetTrace, null, options, request); + } + public virtual global::Jaeger.ApiV2.ArchiveTraceResponse ArchiveTrace(global::Jaeger.ApiV2.ArchiveTraceRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ArchiveTrace(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.ArchiveTraceResponse ArchiveTrace(global::Jaeger.ApiV2.ArchiveTraceRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ArchiveTrace, null, options, request); + } + public virtual grpc::AsyncUnaryCall ArchiveTraceAsync(global::Jaeger.ApiV2.ArchiveTraceRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ArchiveTraceAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall ArchiveTraceAsync(global::Jaeger.ApiV2.ArchiveTraceRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ArchiveTrace, null, options, request); + } + public virtual grpc::AsyncServerStreamingCall FindTraces(global::Jaeger.ApiV2.FindTracesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return FindTraces(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncServerStreamingCall FindTraces(global::Jaeger.ApiV2.FindTracesRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncServerStreamingCall(__Method_FindTraces, null, options, request); + } + public virtual global::Jaeger.ApiV2.GetServicesResponse GetServices(global::Jaeger.ApiV2.GetServicesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetServices(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.GetServicesResponse GetServices(global::Jaeger.ApiV2.GetServicesRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetServices, null, options, request); + } + public virtual grpc::AsyncUnaryCall GetServicesAsync(global::Jaeger.ApiV2.GetServicesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetServicesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall GetServicesAsync(global::Jaeger.ApiV2.GetServicesRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetServices, null, options, request); + } + public virtual global::Jaeger.ApiV2.GetOperationsResponse GetOperations(global::Jaeger.ApiV2.GetOperationsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetOperations(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.GetOperationsResponse GetOperations(global::Jaeger.ApiV2.GetOperationsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetOperations, null, options, request); + } + public virtual grpc::AsyncUnaryCall GetOperationsAsync(global::Jaeger.ApiV2.GetOperationsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetOperationsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall GetOperationsAsync(global::Jaeger.ApiV2.GetOperationsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetOperations, null, options, request); + } + public virtual global::Jaeger.ApiV2.GetDependenciesResponse GetDependencies(global::Jaeger.ApiV2.GetDependenciesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetDependencies(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.GetDependenciesResponse GetDependencies(global::Jaeger.ApiV2.GetDependenciesRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetDependencies, null, options, request); + } + public virtual grpc::AsyncUnaryCall GetDependenciesAsync(global::Jaeger.ApiV2.GetDependenciesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetDependenciesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall GetDependenciesAsync(global::Jaeger.ApiV2.GetDependenciesRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetDependencies, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + protected override QueryServiceClient NewInstance(ClientBaseConfiguration configuration) + { + return new QueryServiceClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + public static grpc::ServerServiceDefinition BindService(QueryServiceBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_GetTrace, serviceImpl.GetTrace) + .AddMethod(__Method_ArchiveTrace, serviceImpl.ArchiveTrace) + .AddMethod(__Method_FindTraces, serviceImpl.FindTraces) + .AddMethod(__Method_GetServices, serviceImpl.GetServices) + .AddMethod(__Method_GetOperations, serviceImpl.GetOperations) + .AddMethod(__Method_GetDependencies, serviceImpl.GetDependencies).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. + public static void BindService(grpc::ServiceBinderBase serviceBinder, QueryServiceBase serviceImpl) + { + serviceBinder.AddMethod(__Method_GetTrace, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod(serviceImpl.GetTrace)); + serviceBinder.AddMethod(__Method_ArchiveTrace, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ArchiveTrace)); + serviceBinder.AddMethod(__Method_FindTraces, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod(serviceImpl.FindTraces)); + serviceBinder.AddMethod(__Method_GetServices, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetServices)); + serviceBinder.AddMethod(__Method_GetOperations, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetOperations)); + serviceBinder.AddMethod(__Method_GetDependencies, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetDependencies)); + } + + } +} +#endregion diff --git a/src/Communication/Jaeger.Communication.Grpc/SamplingGrpc.cs b/src/Communication/Jaeger.Communication.Grpc/SamplingGrpc.cs new file mode 100644 index 000000000..cba413c77 --- /dev/null +++ b/src/Communication/Jaeger.Communication.Grpc/SamplingGrpc.cs @@ -0,0 +1,123 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: sampling.proto +// +// Original file comments: +// Copyright (c) 2019 The Jaeger Authors. +// Copyright (c) 2018 Uber Technologies, Inc. +// +// 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 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace Jaeger.ApiV2 { + public static partial class SamplingManager + { + static readonly string __ServiceName = "jaeger.api_v2.SamplingManager"; + + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_SamplingStrategyParameters = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.SamplingStrategyParameters.Parser.ParseFrom); + static readonly grpc::Marshaller __Marshaller_jaeger_api_v2_SamplingStrategyResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Jaeger.ApiV2.SamplingStrategyResponse.Parser.ParseFrom); + + static readonly grpc::Method __Method_GetSamplingStrategy = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetSamplingStrategy", + __Marshaller_jaeger_api_v2_SamplingStrategyParameters, + __Marshaller_jaeger_api_v2_SamplingStrategyResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Jaeger.ApiV2.SamplingReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of SamplingManager + [grpc::BindServiceMethod(typeof(SamplingManager), "BindService")] + public abstract partial class SamplingManagerBase + { + public virtual global::System.Threading.Tasks.Task GetSamplingStrategy(global::Jaeger.ApiV2.SamplingStrategyParameters request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for SamplingManager + public partial class SamplingManagerClient : grpc::ClientBase + { + /// Creates a new client for SamplingManager + /// The channel to use to make remote calls. + public SamplingManagerClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for SamplingManager that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + public SamplingManagerClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + protected SamplingManagerClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + protected SamplingManagerClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + public virtual global::Jaeger.ApiV2.SamplingStrategyResponse GetSamplingStrategy(global::Jaeger.ApiV2.SamplingStrategyParameters request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetSamplingStrategy(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual global::Jaeger.ApiV2.SamplingStrategyResponse GetSamplingStrategy(global::Jaeger.ApiV2.SamplingStrategyParameters request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetSamplingStrategy, null, options, request); + } + public virtual grpc::AsyncUnaryCall GetSamplingStrategyAsync(global::Jaeger.ApiV2.SamplingStrategyParameters request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetSamplingStrategyAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + public virtual grpc::AsyncUnaryCall GetSamplingStrategyAsync(global::Jaeger.ApiV2.SamplingStrategyParameters request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetSamplingStrategy, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + protected override SamplingManagerClient NewInstance(ClientBaseConfiguration configuration) + { + return new SamplingManagerClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + public static grpc::ServerServiceDefinition BindService(SamplingManagerBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_GetSamplingStrategy, serviceImpl.GetSamplingStrategy).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. + public static void BindService(grpc::ServiceBinderBase serviceBinder, SamplingManagerBase serviceImpl) + { + serviceBinder.AddMethod(__Method_GetSamplingStrategy, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetSamplingStrategy)); + } + + } +} +#endregion diff --git a/src/Senders/Jaeger.Senders.Grpc/Jaeger.Senders.Grpc.csproj b/src/Senders/Jaeger.Senders.Grpc/Jaeger.Senders.Grpc.csproj index 1f66c4b85..5efa151aa 100644 --- a/src/Senders/Jaeger.Senders.Grpc/Jaeger.Senders.Grpc.csproj +++ b/src/Senders/Jaeger.Senders.Grpc/Jaeger.Senders.Grpc.csproj @@ -5,23 +5,8 @@ - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - + - - - - - - -