diff --git a/docker/regen-proto.sh b/docker/regen-proto.sh index 68083b48..ca5ecbcf 100755 --- a/docker/regen-proto.sh +++ b/docker/regen-proto.sh @@ -3,14 +3,15 @@ # Regenerates the gRPC C# files from the Communication project's .proto files. # # Background: protoc (linux/arm64) segfaults inside our Docker build container -# (Grpc.Tools 2.71.0). As a workaround the generated C# is checked into -# src/ZB.MOM.WW.ScadaBridge.Communication/ — SiteStreamGrpc/ for sitestream.proto -# and CentralControlGrpc/ for central_control.proto — and the Protobuf ItemGroup -# in the .csproj is commented out, so Docker just compiles the checked-in files. +# (Grpc.Tools). As a workaround the generated C# is checked into +# src/ZB.MOM.WW.ScadaBridge.Communication/ — SiteStreamGrpc/ for sitestream.proto, +# CentralControlGrpc/ for central_control.proto, and SiteCommandGrpc/ for +# site_command.proto — and the Protobuf ItemGroup in the .csproj is commented out, +# so Docker just compiles the checked-in files. # # Run this script ON YOUR DEV MACHINE whenever a .proto changes: # -# docker/regen-proto.sh [sitestream|centralcontrol|all] (default: all) +# docker/regen-proto.sh [sitestream|centralcontrol|sitecommand|all] (default: all) # # 1. Injects a Protobuf ItemGroup for the selected proto(s) so Grpc.Tools runs. # 2. Deletes the stale checked-in C# so a failed regen is obvious. @@ -32,8 +33,8 @@ set -euo pipefail TARGET="${1:-all}" case "$TARGET" in - sitestream|centralcontrol|all) ;; - *) echo "usage: $0 [sitestream|centralcontrol|all]" >&2; exit 2 ;; + sitestream|centralcontrol|sitecommand|all) ;; + *) echo "usage: $0 [sitestream|centralcontrol|sitecommand|all]" >&2; exit 2 ;; esac SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" @@ -68,6 +69,8 @@ if target in ("sitestream", "all"): protos.append("sitestream.proto") if target in ("centralcontrol", "all"): protos.append("central_control.proto") +if target in ("sitecommand", "all"): + protos.append("site_command.proto") items = "\n".join( f' ' for p in protos) @@ -87,6 +90,10 @@ if [[ "$TARGET" == "centralcontrol" || "$TARGET" == "all" ]]; then rm -f "$COMM_DIR/CentralControlGrpc/CentralControl.cs" \ "$COMM_DIR/CentralControlGrpc/CentralControlGrpc.cs" fi +if [[ "$TARGET" == "sitecommand" || "$TARGET" == "all" ]]; then + rm -f "$COMM_DIR/SiteCommandGrpc/SiteCommand.cs" \ + "$COMM_DIR/SiteCommandGrpc/SiteCommandGrpc.cs" +fi # 3. Regenerate by building. echo "Building Communication project (regen)..." @@ -103,6 +110,11 @@ if [[ "$TARGET" == "centralcontrol" || "$TARGET" == "all" ]]; then cp "$GEN/CentralControl.cs" "$GEN/CentralControlGrpc.cs" "$COMM_DIR/CentralControlGrpc/" echo "Copied regenerated files to CentralControlGrpc/" fi +if [[ "$TARGET" == "sitecommand" || "$TARGET" == "all" ]]; then + mkdir -p "$COMM_DIR/SiteCommandGrpc" + cp "$GEN/SiteCommand.cs" "$GEN/SiteCommandGrpc.cs" "$COMM_DIR/SiteCommandGrpc/" + echo "Copied regenerated files to SiteCommandGrpc/" +fi # 5. Restore the backed-up csproj — i.e. drop the injected ItemGroup — so Docker # builds keep working. @@ -115,4 +127,5 @@ echo "Done. Review and commit:" echo " git diff src/ZB.MOM.WW.ScadaBridge.Communication/Protos/" echo " git diff src/ZB.MOM.WW.ScadaBridge.Communication/SiteStreamGrpc/" echo " git diff src/ZB.MOM.WW.ScadaBridge.Communication/CentralControlGrpc/" +echo " git diff src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/" echo " git diff -- src/ZB.MOM.WW.ScadaBridge.Communication/*.csproj # must be EMPTY" diff --git a/docs/plans/2026-07-22-clusterclient-to-grpc-plan.md b/docs/plans/2026-07-22-clusterclient-to-grpc-plan.md index ca2e82b0..dd399b4b 100644 --- a/docs/plans/2026-07-22-clusterclient-to-grpc-plan.md +++ b/docs/plans/2026-07-22-clusterclient-to-grpc-plan.md @@ -313,10 +313,10 @@ Critical path ≈ 1B: **~4–6 weeks total**, matching the design estimate. - [x] T1A.2 Central hosting: `AddGrpc` + per-site-PSK interceptor (`x-scadabridge-site`), `CentralGrpcPort` h2c listener (8083), `CentralControlGrpcService` (Ask existing handlers), readiness gate - [x] T1A.3 `ICentralTransport` (Akka extract + Grpc impl), `CentralChannelProvider` (sticky failover/failback, backoff, deadlines, PSK), `CentralTransport` flag default `Akka`, `CentralGrpcEndpoints` option + validator - [x] T1A.4 Tests: actor-with-fake-transport ×7, TestServer transport tests, S&F/audit/health suites pass unmodified -- [ ] 1A DoD: rig site-a on `Grpc` proves all 5 site→central paths while site-b/c stay Akka; PR merged (before 1B) +- [x] 1A DoD: rig site-a on `Grpc` proves site→central paths (heartbeat/health/reconcile + coexistence) while site-b/c stay Akka; PR #26 merged (`aa60f438`). Notification/audit deferred to Phase 2 soak (no deployed instance); rig caught + fixed a central `:5000` HTTP-drop regression (`0e162cb2`) **Phase 1B — site command plane** (worktree, `feat/grpc-sitecommand`) -- [x] T1B.1 `site_command.proto` (6 oneof RPCs / 28 commands) + `SiteCommandDtoMapper` + round-trip golden tests (all 28 + replies) +- [x] T1B.1 `site_command.proto` (6 oneof RPCs / 28 commands) + `SiteCommandDtoMapper` + round-trip golden tests (all 28 commands + 22 reply shapes + 18 nested types; reflection-driven coverage guard over the mapper surface and the generated oneof descriptors) - [x] T1B.2 `SiteCommandDispatcher` refactor (actor + new `SiteCommandGrpcService` share it; parked stays node-local) - [x] T1B.3 `ISiteCommandTransport` in `CentralCommunicationActor` (Akka extract + Grpc impl), `SitePairChannelProvider` (Site entity Grpc columns + DB refresh loop), `SiteTransport` flag default `Akka` - [x] T1B.4 Tests: dispatcher routing ×28, actor envelope/reply plumbing, TestServer service tests, existing Communication suites green diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/LooseValueCodec.cs b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/LooseValueCodec.cs new file mode 100644 index 00000000..510ab083 --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/LooseValueCodec.cs @@ -0,0 +1,219 @@ +using System.Collections; +using System.Globalization; +using System.Text.Json; +using Google.Protobuf; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc; + +/// +/// Codec for the loosely-typed object? members that survive on the site +/// command plane — script parameters and return values, attribute values, and +/// OPC UA tag read/write values — mapping them to and from the type-tagged +/// proto carrier. +/// +/// +/// +/// Why a tagged union rather than a string or JSON blob. These values +/// reach an operator's screen (Test Bindings, Debug View) and a device write +/// (WriteTag), so collapsing them to text would change behaviour: today +/// the Akka JSON serializer runs with TypeNameHandling on and preserves +/// the boxed CLR type end-to-end. The tags below cover every CLR type these +/// fields actually carry, so those values keep their runtime type across the +/// wire exactly as they do over Akka remoting. +/// +/// +/// The one documented lossy path. Anything outside the tagged set — +/// an exotic numeric (, , …), an enum, a +/// POCO — falls back to and decodes as a +/// rather than its original CLR type. The value +/// itself is preserved; its CLR identity is not. Collections and string-keyed +/// dictionaries do NOT take that path: they encode recursively (see +/// /) and decode to +/// List<object?> / Dictionary<string, object?>, so +/// their ELEMENTS keep their types while the container type widens. +/// +/// +/// Why dates ride as strings. google.protobuf.Timestamp +/// normalises everything to UTC, which silently discards +/// and . For a +/// timestamped tag value that is data loss, not normalisation, so +/// // +/// use invariant round-trip formats instead. (Message FIELDS that are declared +/// DateTimeOffset in the DTO are a different case and do use +/// Timestamp — see .) +/// +/// +public static class LooseValueCodec +{ + private static readonly JsonSerializerOptions JsonOpts = new() { WriteIndented = false }; + + /// + /// Encodes a boxed value for a NULLABLE message field: null returns + /// null so the field is simply left unset on the wire. + /// + /// The boxed value to encode, or null. + /// The encoded carrier, or null when is null. + public static LooseValue? ToProtoOrNull(object? value) => + value is null ? null : ToProto(value); + + /// + /// Encodes a boxed value, representing null explicitly as + /// . Used inside maps and lists, where an absent + /// entry means "no such key/element" rather than "a null value". + /// + /// The boxed value to encode, or null. + /// A populated ; never null. + public static LooseValue ToProto(object? value) => value switch + { + null => new LooseValue { NullValue = new LooseNull() }, + bool b => new LooseValue { BoolValue = b }, + int i => new LooseValue { Int32Value = i }, + long l => new LooseValue { Int64Value = l }, + double d => new LooseValue { DoubleValue = d }, + float f => new LooseValue { FloatValue = f }, + string s => new LooseValue { StringValue = s }, + decimal m => new LooseValue { DecimalValue = m.ToString(CultureInfo.InvariantCulture) }, + DateTime dt => new LooseValue { DateTimeValue = dt.ToString("O", CultureInfo.InvariantCulture) }, + DateTimeOffset dto => new LooseValue { DateTimeOffsetValue = dto.ToString("O", CultureInfo.InvariantCulture) }, + Guid g => new LooseValue { GuidValue = g.ToString("D") }, + TimeSpan ts => new LooseValue { TimeSpanValue = ts.ToString("c", CultureInfo.InvariantCulture) }, + byte[] bytes => new LooseValue { BytesValue = ByteString.CopyFrom(bytes) }, + IDictionary dict => new LooseValue { MapValue = ToMap(dict) }, + IEnumerable seq => new LooseValue { ListValue = ToList(seq) }, + // Escape hatch. Preserves the value, not the CLR type — see the remarks. + _ => new LooseValue { JsonValue = JsonSerializer.Serialize(value, value.GetType(), JsonOpts) } + }; + + /// + /// Decodes a carrier back to a boxed value. An unset field + /// (null) and an explicit both decode to + /// null, so the two encoders above are interchangeable on read. + /// + /// The carrier to decode, or null when the field was unset. + /// The decoded boxed value; null for an unset or explicitly-null carrier. + public static object? FromProto(LooseValue? value) + { + if (value is null) + { + return null; + } + + return value.KindCase switch + { + LooseValue.KindOneofCase.None => null, + LooseValue.KindOneofCase.NullValue => null, + LooseValue.KindOneofCase.BoolValue => value.BoolValue, + LooseValue.KindOneofCase.Int32Value => value.Int32Value, + LooseValue.KindOneofCase.Int64Value => value.Int64Value, + LooseValue.KindOneofCase.DoubleValue => value.DoubleValue, + LooseValue.KindOneofCase.FloatValue => value.FloatValue, + LooseValue.KindOneofCase.StringValue => value.StringValue, + LooseValue.KindOneofCase.DecimalValue => + decimal.Parse(value.DecimalValue, CultureInfo.InvariantCulture), + LooseValue.KindOneofCase.DateTimeValue => + DateTime.Parse(value.DateTimeValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind), + LooseValue.KindOneofCase.DateTimeOffsetValue => + DateTimeOffset.Parse(value.DateTimeOffsetValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind), + LooseValue.KindOneofCase.GuidValue => Guid.Parse(value.GuidValue), + LooseValue.KindOneofCase.TimeSpanValue => + TimeSpan.ParseExact(value.TimeSpanValue, "c", CultureInfo.InvariantCulture), + LooseValue.KindOneofCase.BytesValue => value.BytesValue.ToByteArray(), + LooseValue.KindOneofCase.ListValue => FromList(value.ListValue), + LooseValue.KindOneofCase.MapValue => FromMap(value.MapValue), + LooseValue.KindOneofCase.JsonValue => JsonSerializer.Deserialize(value.JsonValue), + _ => null + }; + } + + /// + /// Encodes a string-keyed dictionary onto the wire. Null values are carried + /// explicitly (), so a key present with a null value + /// stays distinct from an absent key. + /// + /// The dictionary to encode. + /// A populated . + public static LooseValueMap ToProtoMap(IReadOnlyDictionary values) + { + ArgumentNullException.ThrowIfNull(values); + + var map = new LooseValueMap(); + foreach (var (key, value) in values) + { + map.Entries[key] = ToProto(value); + } + + return map; + } + + /// + /// Encodes a NULLABLE string-keyed dictionary: null returns + /// null so the field is left unset and the null/empty distinction + /// survives (proto3 map alone cannot express it). + /// + /// The dictionary to encode, or null. + /// The encoded map, or null when is null. + public static LooseValueMap? ToProtoMapOrNull(IReadOnlyDictionary? values) => + values is null ? null : ToProtoMap(values); + + /// Decodes a wire map back to a dictionary; an unset field decodes to null. + /// The wire map, or null when the field was unset. + /// The decoded dictionary, or null. + public static IReadOnlyDictionary? FromProtoMapOrNull(LooseValueMap? map) => + map is null ? null : FromMap(map); + + /// Decodes a wire map back to a dictionary; an unset field decodes to an EMPTY dictionary. + /// For DTO members that are declared non-nullable, so "absent" can only mean "empty". + /// The wire map, or null when the field was unset. + /// The decoded dictionary; empty when is null. + public static IReadOnlyDictionary FromProtoMap(LooseValueMap? map) => + map is null ? new Dictionary() : FromMap(map); + + private static LooseValueList ToList(IEnumerable source) + { + var list = new LooseValueList(); + foreach (var element in source) + { + list.Items.Add(ToProto(element)); + } + + return list; + } + + private static LooseValueMap ToMap(IDictionary source) + { + var map = new LooseValueMap(); + foreach (DictionaryEntry entry in source) + { + // Non-string keys are outside the wire contract; the invariant-culture + // rendering keeps the entry readable rather than dropping it silently. + var key = entry.Key as string + ?? Convert.ToString(entry.Key, CultureInfo.InvariantCulture) + ?? string.Empty; + map.Entries[key] = ToProto(entry.Value); + } + + return map; + } + + private static List FromList(LooseValueList list) + { + var result = new List(list.Items.Count); + foreach (var item in list.Items) + { + result.Add(FromProto(item)); + } + + return result; + } + + private static Dictionary FromMap(LooseValueMap map) + { + var result = new Dictionary(map.Entries.Count); + foreach (var (key, value) in map.Entries) + { + result[key] = FromProto(value); + } + + return result; + } +} diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandDtoMapper.cs b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandDtoMapper.cs new file mode 100644 index 00000000..f9b850c7 --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandDtoMapper.cs @@ -0,0 +1,3040 @@ +using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Protocol; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Artifacts; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.DataConnection; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.InboundApi; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Lifecycle; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Streaming; +using ZB.MOM.WW.ScadaBridge.Commons.Types; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Alarms; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums; +using BoolValue = Google.Protobuf.WellKnownTypes.BoolValue; +using Duration = Google.Protobuf.WellKnownTypes.Duration; +using Int32Value = Google.Protobuf.WellKnownTypes.Int32Value; +using StringValue = Google.Protobuf.WellKnownTypes.StringValue; +using Timestamp = Google.Protobuf.WellKnownTypes.Timestamp; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc; + +/// +/// Canonical bridge between the in-process central→site command/reply records +/// (Commons Messages.*) and the wire messages of +/// Protos/site_command.proto. Every one of the 28 migrated commands and +/// all 22 reply shapes pass through here; nothing else may hand-roll the +/// translation, so the contract has exactly one definition. +/// +/// +/// +/// Mirrors the sibling / +/// and lives in Communication for the same reason: this project owns the +/// generated wire types and already references Commons, so both the site +/// server (T1B.2) and the central transport (T1B.3) can share one implementation +/// without a project-reference cycle. +/// +/// +/// Excluded by design: IntegrationCallRequest. It is the 29th +/// command on SiteCommunicationActor's receive table but is dead at both +/// ends — no production code registers the integration handler, so the site +/// always answers "Integration handler not available". See +/// docs/known-issues/2026-07-22-integration-call-routing-is-dead-code.md. +/// +/// Null conventions. proto3 has no presence for scalars, so: +/// +/// +/// Nullable strings ride as plain string and the empty string +/// represents null — the convention +/// already established. It is a normalisation, not a loss: every such member +/// here is an optional error message, token, filter or id where "" and +/// null carry the same meaning. The one exception is +/// , where +/// "wait for the empty string" is a real target distinct from "no target"; +/// that field uses a StringValue wrapper instead. +/// +/// +/// Nullable ints/bools use the Int32Value/BoolValue +/// wrappers, and nullable enums use a one-field message of the same +/// shape (proto3 enums have no presence and no stock wrapper exists). +/// +/// +/// Nullable collections are wrapped in a per-collection message, so +/// the null/empty distinction becomes a message-presence question. proto3 +/// repeated/map alone collapses the two — precisely the silent +/// data-loss class the transport round-trip guard caught in PLAN-05 T8. +/// +/// +/// Guid? members ride as a string holding the "D" form, with +/// the empty string representing null. +/// (a non-nullable struct over a +/// ) rides as the same "D" string. +/// +/// +/// +/// Time. DTO members declared use +/// google.protobuf.Timestamp. That normalises to UTC, which is lossless +/// under equality (it compares instants), and every +/// timestamp in this contract is documented UTC anyway. Members declared +/// (the certificate validity bounds) are coerced to +/// first, matching their …Utc names. +/// Loosely-typed object? values are the exception and keep their exact +/// kind/offset — see . +/// +/// +/// Enums translate through explicit switches in both directions, never by +/// ordinal, so reordering a C# enum cannot silently re-map the wire. Every wire +/// enum reserves 0 for _UNSPECIFIED; decoding an unspecified or unknown +/// value yields the documented safe default for that enum (never a throw — a +/// version-skewed peer must not be able to fault a whole command). +/// +/// +public static class SiteCommandDtoMapper +{ + // ───────────────────────────────────────────────────────────────────── + // Group classification — the authoritative 28-command inventory in code. + // ───────────────────────────────────────────────────────────────────── + + /// + /// Classifies a central→site command onto the RPC group that carries it. + /// The central transport (T1B.3) uses this to pick both the RPC and the + /// deadline; the coverage tests use it as the command inventory. + /// + /// The command record to classify. + /// The whose RPC carries the command. + /// The type is not part of the migrated command set. + public static SiteCommandGroup GroupOf(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + RefreshDeploymentCommand or EnableInstanceCommand or DisableInstanceCommand + or DeleteInstanceCommand or DeploymentStateQueryRequest or DeployArtifactsCommand + => SiteCommandGroup.Lifecycle, + + BrowseNodeCommand or SearchAddressSpaceCommand or ReadTagValuesCommand + or VerifyEndpointCommand or TrustServerCertCommand or ListServerCertsCommand + or RemoveServerCertCommand or WriteTagRequest + => SiteCommandGroup.OpcUa, + + EventLogQueryRequest or DebugSnapshotRequest or SubscribeDebugViewRequest + or UnsubscribeDebugViewRequest + => SiteCommandGroup.Query, + + ParkedMessageQueryRequest or ParkedMessageRetryRequest or ParkedMessageDiscardRequest + or RetryParkedOperation or DiscardParkedOperation + => SiteCommandGroup.Parked, + + RouteToCallRequest or RouteToGetAttributesRequest or RouteToSetAttributesRequest + or RouteToWaitForAttributeRequest + => SiteCommandGroup.Route, + + TriggerSiteFailover => SiteCommandGroup.Failover, + + _ => throw new ArgumentException( + $"'{command.GetType().Name}' is not a migrated site command.", nameof(command)) + }; + } + + /// + /// Classifies a site→central reply onto the RPC group whose reply envelope + /// carries it — the mirror of , used by the site + /// dispatcher to pack whatever a handler answered into the right envelope. + /// + /// The reply record to classify. + /// The whose reply envelope carries it. + /// The type is not a migrated reply shape. + public static SiteCommandGroup GroupOfReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + DeploymentStatusResponse or InstanceLifecycleResponse or DeploymentStateQueryResponse + or ArtifactDeploymentResponse + => SiteCommandGroup.Lifecycle, + + BrowseNodeResult or SearchAddressSpaceResult or ReadTagValuesResult or VerifyEndpointResult + or CertTrustResult or WriteTagResponse + => SiteCommandGroup.OpcUa, + + EventLogQueryResponse or DebugViewSnapshot or UnsubscribeDebugViewAck + => SiteCommandGroup.Query, + + ParkedMessageQueryResponse or ParkedMessageRetryResponse or ParkedMessageDiscardResponse + or ParkedOperationActionAck + => SiteCommandGroup.Parked, + + RouteToCallResponse or RouteToGetAttributesResponse or RouteToSetAttributesResponse + or RouteToWaitForAttributeResponse + => SiteCommandGroup.Route, + + SiteFailoverAck => SiteCommandGroup.Failover, + + _ => throw new ArgumentException( + $"'{reply.GetType().Name}' is not a migrated site reply.", nameof(reply)) + }; + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 1 — ExecuteLifecycle: envelopes + // ───────────────────────────────────────────────────────────────────── + + /// Packs a lifecycle-group command into its request envelope. + /// One of the six lifecycle-group commands. + /// The populated request envelope. + /// The command does not belong to this group. + public static LifecycleRequest ToLifecycleRequest(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + RefreshDeploymentCommand c => new LifecycleRequest { RefreshDeployment = ToProto(c) }, + EnableInstanceCommand c => new LifecycleRequest { EnableInstance = ToProto(c) }, + DisableInstanceCommand c => new LifecycleRequest { DisableInstance = ToProto(c) }, + DeleteInstanceCommand c => new LifecycleRequest { DeleteInstance = ToProto(c) }, + DeploymentStateQueryRequest c => new LifecycleRequest { DeploymentStateQuery = ToProto(c) }, + DeployArtifactsCommand c => new LifecycleRequest { DeployArtifacts = ToProto(c) }, + _ => throw NotInGroup(command, SiteCommandGroup.Lifecycle) + }; + } + + /// Unpacks a lifecycle-group request envelope back to its command record. + /// The request envelope received on the wire. + /// The decoded command record. + /// The envelope carries no case this build knows. + public static object FromLifecycleRequest(LifecycleRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return request.CommandCase switch + { + LifecycleRequest.CommandOneofCase.RefreshDeployment => FromProto(request.RefreshDeployment), + LifecycleRequest.CommandOneofCase.EnableInstance => FromProto(request.EnableInstance), + LifecycleRequest.CommandOneofCase.DisableInstance => FromProto(request.DisableInstance), + LifecycleRequest.CommandOneofCase.DeleteInstance => FromProto(request.DeleteInstance), + LifecycleRequest.CommandOneofCase.DeploymentStateQuery => FromProto(request.DeploymentStateQuery), + LifecycleRequest.CommandOneofCase.DeployArtifacts => FromProto(request.DeployArtifacts), + _ => throw UnknownCase(request.CommandCase, nameof(LifecycleRequest)) + }; + } + + /// Packs a lifecycle-group reply into its reply envelope. + /// One of the four lifecycle-group reply records. + /// The populated reply envelope. + /// The reply does not belong to this group. + public static LifecycleReply ToLifecycleReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + DeploymentStatusResponse r => new LifecycleReply { DeploymentStatus = ToProto(r) }, + InstanceLifecycleResponse r => new LifecycleReply { InstanceLifecycle = ToProto(r) }, + DeploymentStateQueryResponse r => new LifecycleReply { DeploymentStateQuery = ToProto(r) }, + ArtifactDeploymentResponse r => new LifecycleReply { ArtifactDeployment = ToProto(r) }, + _ => throw NotInGroup(reply, SiteCommandGroup.Lifecycle) + }; + } + + /// Unpacks a lifecycle-group reply envelope back to its reply record. + /// The reply envelope received on the wire. + /// The decoded reply record. + /// The envelope carries no case this build knows. + public static object FromLifecycleReply(LifecycleReply reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply.ReplyCase switch + { + LifecycleReply.ReplyOneofCase.DeploymentStatus => FromProto(reply.DeploymentStatus), + LifecycleReply.ReplyOneofCase.InstanceLifecycle => FromProto(reply.InstanceLifecycle), + LifecycleReply.ReplyOneofCase.DeploymentStateQuery => FromProto(reply.DeploymentStateQuery), + LifecycleReply.ReplyOneofCase.ArtifactDeployment => FromProto(reply.ArtifactDeployment), + _ => throw UnknownCase(reply.ReplyCase, nameof(LifecycleReply)) + }; + } + + // ── Lifecycle commands ── + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static RefreshDeploymentCommandDto ToProto(RefreshDeploymentCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new RefreshDeploymentCommandDto + { + DeploymentId = command.DeploymentId, + InstanceUniqueName = command.InstanceUniqueName, + RevisionHash = command.RevisionHash, + DeployedBy = command.DeployedBy, + Timestamp = Ts(command.Timestamp), + CentralFetchBaseUrl = command.CentralFetchBaseUrl, + FetchToken = command.FetchToken + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static RefreshDeploymentCommand FromProto(RefreshDeploymentCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RefreshDeploymentCommand( + dto.DeploymentId, + dto.InstanceUniqueName, + dto.RevisionHash, + dto.DeployedBy, + Dto(dto.Timestamp), + dto.CentralFetchBaseUrl, + dto.FetchToken); + } + + /// Projects an onto the wire. + /// The command to project. + /// The wire message. + public static EnableInstanceCommandDto ToProto(EnableInstanceCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new EnableInstanceCommandDto + { + CommandId = command.CommandId, + InstanceUniqueName = command.InstanceUniqueName, + Timestamp = Ts(command.Timestamp) + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded command record. + public static EnableInstanceCommand FromProto(EnableInstanceCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new EnableInstanceCommand(dto.CommandId, dto.InstanceUniqueName, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static DisableInstanceCommandDto ToProto(DisableInstanceCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new DisableInstanceCommandDto + { + CommandId = command.CommandId, + InstanceUniqueName = command.InstanceUniqueName, + Timestamp = Ts(command.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static DisableInstanceCommand FromProto(DisableInstanceCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DisableInstanceCommand(dto.CommandId, dto.InstanceUniqueName, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static DeleteInstanceCommandDto ToProto(DeleteInstanceCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new DeleteInstanceCommandDto + { + CommandId = command.CommandId, + InstanceUniqueName = command.InstanceUniqueName, + Timestamp = Ts(command.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static DeleteInstanceCommand FromProto(DeleteInstanceCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DeleteInstanceCommand(dto.CommandId, dto.InstanceUniqueName, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static DeploymentStateQueryRequestDto ToProto(DeploymentStateQueryRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new DeploymentStateQueryRequestDto + { + CorrelationId = request.CorrelationId, + InstanceUniqueName = request.InstanceUniqueName, + Timestamp = Ts(request.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static DeploymentStateQueryRequest FromProto(DeploymentStateQueryRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DeploymentStateQueryRequest(dto.CorrelationId, dto.InstanceUniqueName, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// Each artifact collection is nullable; a null collection leaves its wrapper message unset. + /// The command to project. + /// The wire message. + public static DeployArtifactsCommandDto ToProto(DeployArtifactsCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + var dto = new DeployArtifactsCommandDto + { + DeploymentId = command.DeploymentId, + Timestamp = Ts(command.Timestamp) + }; + + if (command.SharedScripts is not null) + { + var list = new SharedScriptArtifactListDto(); + list.Items.AddRange(command.SharedScripts.Select(ToProto)); + dto.SharedScripts = list; + } + + if (command.ExternalSystems is not null) + { + var list = new ExternalSystemArtifactListDto(); + list.Items.AddRange(command.ExternalSystems.Select(ToProto)); + dto.ExternalSystems = list; + } + + if (command.DatabaseConnections is not null) + { + var list = new DatabaseConnectionArtifactListDto(); + list.Items.AddRange(command.DatabaseConnections.Select(ToProto)); + dto.DatabaseConnections = list; + } + + if (command.NotificationLists is not null) + { + var list = new NotificationListArtifactListDto(); + list.Items.AddRange(command.NotificationLists.Select(ToProto)); + dto.NotificationLists = list; + } + + if (command.DataConnections is not null) + { + var list = new DataConnectionArtifactListDto(); + list.Items.AddRange(command.DataConnections.Select(ToProto)); + dto.DataConnections = list; + } + + if (command.SmtpConfigurations is not null) + { + var list = new SmtpConfigurationArtifactListDto(); + list.Items.AddRange(command.SmtpConfigurations.Select(ToProto)); + dto.SmtpConfigurations = list; + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record; unset collection wrappers rehydrate as null. + public static DeployArtifactsCommand FromProto(DeployArtifactsCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DeployArtifactsCommand( + dto.DeploymentId, + dto.SharedScripts is null ? null : dto.SharedScripts.Items.Select(FromProto).ToList(), + dto.ExternalSystems is null ? null : dto.ExternalSystems.Items.Select(FromProto).ToList(), + dto.DatabaseConnections is null ? null : dto.DatabaseConnections.Items.Select(FromProto).ToList(), + dto.NotificationLists is null ? null : dto.NotificationLists.Items.Select(FromProto).ToList(), + dto.DataConnections is null ? null : dto.DataConnections.Items.Select(FromProto).ToList(), + dto.SmtpConfigurations is null ? null : dto.SmtpConfigurations.Items.Select(FromProto).ToList(), + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The artifact to project. + /// The wire message. + public static SharedScriptArtifactDto ToProto(SharedScriptArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + return new SharedScriptArtifactDto + { + Name = artifact.Name, + Code = artifact.Code, + ParameterDefinitions = OrEmpty(artifact.ParameterDefinitions), + ReturnDefinition = OrEmpty(artifact.ReturnDefinition) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static SharedScriptArtifact FromProto(SharedScriptArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SharedScriptArtifact( + dto.Name, dto.Code, NullIfEmpty(dto.ParameterDefinitions), NullIfEmpty(dto.ReturnDefinition)); + } + + /// Projects an onto the wire. + /// The artifact to project. + /// The wire message. + public static ExternalSystemArtifactDto ToProto(ExternalSystemArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + return new ExternalSystemArtifactDto + { + Name = artifact.Name, + EndpointUrl = artifact.EndpointUrl, + AuthType = artifact.AuthType, + AuthConfiguration = OrEmpty(artifact.AuthConfiguration), + MethodDefinitionsJson = OrEmpty(artifact.MethodDefinitionsJson), + TimeoutSeconds = artifact.TimeoutSeconds + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static ExternalSystemArtifact FromProto(ExternalSystemArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ExternalSystemArtifact( + dto.Name, + dto.EndpointUrl, + dto.AuthType, + NullIfEmpty(dto.AuthConfiguration), + NullIfEmpty(dto.MethodDefinitionsJson), + dto.TimeoutSeconds); + } + + /// Projects a onto the wire. + /// The artifact to project. + /// The wire message. + public static DatabaseConnectionArtifactDto ToProto(DatabaseConnectionArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + return new DatabaseConnectionArtifactDto + { + Name = artifact.Name, + ConnectionString = artifact.ConnectionString, + MaxRetries = artifact.MaxRetries, + RetryDelay = Duration.FromTimeSpan(artifact.RetryDelay) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static DatabaseConnectionArtifact FromProto(DatabaseConnectionArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DatabaseConnectionArtifact( + dto.Name, dto.ConnectionString, dto.MaxRetries, dto.RetryDelay?.ToTimeSpan() ?? TimeSpan.Zero); + } + + /// Projects a onto the wire. + /// The artifact to project. + /// The wire message. + public static NotificationListArtifactDto ToProto(NotificationListArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + var dto = new NotificationListArtifactDto { Name = artifact.Name }; + dto.RecipientEmails.AddRange(artifact.RecipientEmails); + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static NotificationListArtifact FromProto(NotificationListArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new NotificationListArtifact(dto.Name, dto.RecipientEmails.ToList()); + } + + /// Projects a onto the wire. + /// The artifact to project. + /// The wire message. + public static DataConnectionArtifactDto ToProto(DataConnectionArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + return new DataConnectionArtifactDto + { + Name = artifact.Name, + Protocol = artifact.Protocol, + PrimaryConfigurationJson = OrEmpty(artifact.PrimaryConfigurationJson), + BackupConfigurationJson = OrEmpty(artifact.BackupConfigurationJson), + FailoverRetryCount = artifact.FailoverRetryCount + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static DataConnectionArtifact FromProto(DataConnectionArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DataConnectionArtifact( + dto.Name, + dto.Protocol, + NullIfEmpty(dto.PrimaryConfigurationJson), + NullIfEmpty(dto.BackupConfigurationJson), + dto.FailoverRetryCount); + } + + /// Projects an onto the wire. + /// The artifact to project. + /// The wire message. + public static SmtpConfigurationArtifactDto ToProto(SmtpConfigurationArtifact artifact) + { + ArgumentNullException.ThrowIfNull(artifact); + + return new SmtpConfigurationArtifactDto + { + Name = artifact.Name, + Server = artifact.Server, + Port = artifact.Port, + AuthMode = artifact.AuthMode, + FromAddress = artifact.FromAddress, + Username = OrEmpty(artifact.Username), + Password = OrEmpty(artifact.Password), + OauthConfig = OrEmpty(artifact.OAuthConfig) + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded artifact. + public static SmtpConfigurationArtifact FromProto(SmtpConfigurationArtifactDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SmtpConfigurationArtifact( + dto.Name, + dto.Server, + dto.Port, + dto.AuthMode, + dto.FromAddress, + NullIfEmpty(dto.Username), + NullIfEmpty(dto.Password), + NullIfEmpty(dto.OauthConfig)); + } + + // ── Lifecycle replies ── + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static DeploymentStatusResponseDto ToProto(DeploymentStatusResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new DeploymentStatusResponseDto + { + DeploymentId = response.DeploymentId, + InstanceUniqueName = response.InstanceUniqueName, + Status = ToProto(response.Status), + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static DeploymentStatusResponse FromProto(DeploymentStatusResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DeploymentStatusResponse( + dto.DeploymentId, + dto.InstanceUniqueName, + FromProto(dto.Status), + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects an onto the wire. + /// The reply to project. + /// The wire message. + public static InstanceLifecycleResponseDto ToProto(InstanceLifecycleResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new InstanceLifecycleResponseDto + { + CommandId = response.CommandId, + InstanceUniqueName = response.InstanceUniqueName, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static InstanceLifecycleResponse FromProto(InstanceLifecycleResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new InstanceLifecycleResponse( + dto.CommandId, + dto.InstanceUniqueName, + dto.Success, + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static DeploymentStateQueryResponseDto ToProto(DeploymentStateQueryResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new DeploymentStateQueryResponseDto + { + CorrelationId = response.CorrelationId, + InstanceUniqueName = response.InstanceUniqueName, + IsDeployed = response.IsDeployed, + AppliedDeploymentId = OrEmpty(response.AppliedDeploymentId), + AppliedRevisionHash = OrEmpty(response.AppliedRevisionHash), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static DeploymentStateQueryResponse FromProto(DeploymentStateQueryResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DeploymentStateQueryResponse( + dto.CorrelationId, + dto.InstanceUniqueName, + dto.IsDeployed, + NullIfEmpty(dto.AppliedDeploymentId), + NullIfEmpty(dto.AppliedRevisionHash), + Dto(dto.Timestamp)); + } + + /// Projects an onto the wire. + /// The reply to project. + /// The wire message. + public static ArtifactDeploymentResponseDto ToProto(ArtifactDeploymentResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new ArtifactDeploymentResponseDto + { + DeploymentId = response.DeploymentId, + SiteId = response.SiteId, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static ArtifactDeploymentResponse FromProto(ArtifactDeploymentResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ArtifactDeploymentResponse( + dto.DeploymentId, dto.SiteId, dto.Success, NullIfEmpty(dto.ErrorMessage), Dto(dto.Timestamp)); + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 2 — ExecuteOpcUa: envelopes + // ───────────────────────────────────────────────────────────────────── + + /// Packs an OPC UA-group command into its request envelope. + /// One of the eight OPC UA-group commands. + /// The populated request envelope. + /// The command does not belong to this group. + public static OpcUaRequest ToOpcUaRequest(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + BrowseNodeCommand c => new OpcUaRequest { BrowseNode = ToProto(c) }, + SearchAddressSpaceCommand c => new OpcUaRequest { SearchAddressSpace = ToProto(c) }, + ReadTagValuesCommand c => new OpcUaRequest { ReadTagValues = ToProto(c) }, + VerifyEndpointCommand c => new OpcUaRequest { VerifyEndpoint = ToProto(c) }, + TrustServerCertCommand c => new OpcUaRequest { TrustServerCert = ToProto(c) }, + ListServerCertsCommand c => new OpcUaRequest { ListServerCerts = ToProto(c) }, + RemoveServerCertCommand c => new OpcUaRequest { RemoveServerCert = ToProto(c) }, + WriteTagRequest c => new OpcUaRequest { WriteTag = ToProto(c) }, + _ => throw NotInGroup(command, SiteCommandGroup.OpcUa) + }; + } + + /// Unpacks an OPC UA-group request envelope back to its command record. + /// The request envelope received on the wire. + /// The decoded command record. + /// The envelope carries no case this build knows. + public static object FromOpcUaRequest(OpcUaRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return request.CommandCase switch + { + OpcUaRequest.CommandOneofCase.BrowseNode => FromProto(request.BrowseNode), + OpcUaRequest.CommandOneofCase.SearchAddressSpace => FromProto(request.SearchAddressSpace), + OpcUaRequest.CommandOneofCase.ReadTagValues => FromProto(request.ReadTagValues), + OpcUaRequest.CommandOneofCase.VerifyEndpoint => FromProto(request.VerifyEndpoint), + OpcUaRequest.CommandOneofCase.TrustServerCert => FromProto(request.TrustServerCert), + OpcUaRequest.CommandOneofCase.ListServerCerts => FromProto(request.ListServerCerts), + OpcUaRequest.CommandOneofCase.RemoveServerCert => FromProto(request.RemoveServerCert), + OpcUaRequest.CommandOneofCase.WriteTag => FromProto(request.WriteTag), + _ => throw UnknownCase(request.CommandCase, nameof(OpcUaRequest)) + }; + } + + /// Packs an OPC UA-group reply into its reply envelope. + /// One of the six OPC UA-group reply records. + /// The populated reply envelope. + /// The reply does not belong to this group. + public static OpcUaReply ToOpcUaReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + BrowseNodeResult r => new OpcUaReply { BrowseNode = ToProto(r) }, + SearchAddressSpaceResult r => new OpcUaReply { SearchAddressSpace = ToProto(r) }, + ReadTagValuesResult r => new OpcUaReply { ReadTagValues = ToProto(r) }, + VerifyEndpointResult r => new OpcUaReply { VerifyEndpoint = ToProto(r) }, + CertTrustResult r => new OpcUaReply { CertTrust = ToProto(r) }, + WriteTagResponse r => new OpcUaReply { WriteTag = ToProto(r) }, + _ => throw NotInGroup(reply, SiteCommandGroup.OpcUa) + }; + } + + /// Unpacks an OPC UA-group reply envelope back to its reply record. + /// The reply envelope received on the wire. + /// The decoded reply record. + /// The envelope carries no case this build knows. + public static object FromOpcUaReply(OpcUaReply reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply.ReplyCase switch + { + OpcUaReply.ReplyOneofCase.BrowseNode => FromProto(reply.BrowseNode), + OpcUaReply.ReplyOneofCase.SearchAddressSpace => FromProto(reply.SearchAddressSpace), + OpcUaReply.ReplyOneofCase.ReadTagValues => FromProto(reply.ReadTagValues), + OpcUaReply.ReplyOneofCase.VerifyEndpoint => FromProto(reply.VerifyEndpoint), + OpcUaReply.ReplyOneofCase.CertTrust => FromProto(reply.CertTrust), + OpcUaReply.ReplyOneofCase.WriteTag => FromProto(reply.WriteTag), + _ => throw UnknownCase(reply.ReplyCase, nameof(OpcUaReply)) + }; + } + + // ── OPC UA commands ── + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static BrowseNodeCommandDto ToProto(BrowseNodeCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new BrowseNodeCommandDto + { + ConnectionName = command.ConnectionName, + ParentNodeId = OrEmpty(command.ParentNodeId), + ContinuationToken = OrEmpty(command.ContinuationToken), + SiteIdentifier = OrEmpty(command.SiteIdentifier) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static BrowseNodeCommand FromProto(BrowseNodeCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new BrowseNodeCommand( + dto.ConnectionName, + NullIfEmpty(dto.ParentNodeId), + NullIfEmpty(dto.ContinuationToken), + NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static SearchAddressSpaceCommandDto ToProto(SearchAddressSpaceCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new SearchAddressSpaceCommandDto + { + ConnectionName = command.ConnectionName, + Query = command.Query, + MaxDepth = command.MaxDepth, + MaxResults = command.MaxResults, + SiteIdentifier = OrEmpty(command.SiteIdentifier) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static SearchAddressSpaceCommand FromProto(SearchAddressSpaceCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SearchAddressSpaceCommand( + dto.ConnectionName, dto.Query, dto.MaxDepth, dto.MaxResults, NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static ReadTagValuesCommandDto ToProto(ReadTagValuesCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + var dto = new ReadTagValuesCommandDto { ConnectionName = command.ConnectionName }; + dto.TagPaths.AddRange(command.TagPaths); + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static ReadTagValuesCommand FromProto(ReadTagValuesCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ReadTagValuesCommand(dto.ConnectionName, dto.TagPaths.ToList()); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static VerifyEndpointCommandDto ToProto(VerifyEndpointCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new VerifyEndpointCommandDto + { + ConnectionName = command.ConnectionName, + Protocol = command.Protocol, + ConfigJson = command.ConfigJson, + SiteIdentifier = OrEmpty(command.SiteIdentifier) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static VerifyEndpointCommand FromProto(VerifyEndpointCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new VerifyEndpointCommand( + dto.ConnectionName, dto.Protocol, dto.ConfigJson, NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static TrustServerCertCommandDto ToProto(TrustServerCertCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new TrustServerCertCommandDto + { + ConnectionName = command.ConnectionName, + DerBase64 = command.DerBase64, + Thumbprint = command.Thumbprint, + SiteIdentifier = OrEmpty(command.SiteIdentifier) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static TrustServerCertCommand FromProto(TrustServerCertCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new TrustServerCertCommand( + dto.ConnectionName, dto.DerBase64, dto.Thumbprint, NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static ListServerCertsCommandDto ToProto(ListServerCertsCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new ListServerCertsCommandDto { SiteIdentifier = OrEmpty(command.SiteIdentifier) }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static ListServerCertsCommand FromProto(ListServerCertsCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ListServerCertsCommand(NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The command to project. + /// The wire message. + public static RemoveServerCertCommandDto ToProto(RemoveServerCertCommand command) + { + ArgumentNullException.ThrowIfNull(command); + + return new RemoveServerCertCommandDto + { + Thumbprint = command.Thumbprint, + SiteIdentifier = OrEmpty(command.SiteIdentifier) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded command record. + public static RemoveServerCertCommand FromProto(RemoveServerCertCommandDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RemoveServerCertCommand(dto.Thumbprint, NullIfEmpty(dto.SiteIdentifier)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static WriteTagRequestDto ToProto(WriteTagRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new WriteTagRequestDto + { + CorrelationId = request.CorrelationId, + ConnectionName = request.ConnectionName, + TagPath = request.TagPath, + Value = LooseValueCodec.ToProtoOrNull(request.Value), + Timestamp = Ts(request.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static WriteTagRequest FromProto(WriteTagRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new WriteTagRequest( + dto.CorrelationId, + dto.ConnectionName, + dto.TagPath, + LooseValueCodec.FromProto(dto.Value), + Dto(dto.Timestamp)); + } + + // ── OPC UA replies ── + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static BrowseNodeResultDto ToProto(BrowseNodeResult result) + { + ArgumentNullException.ThrowIfNull(result); + + var dto = new BrowseNodeResultDto + { + Truncated = result.Truncated, + ContinuationToken = OrEmpty(result.ContinuationToken) + }; + dto.Children.AddRange(result.Children.Select(ToProto)); + if (result.Failure is not null) + { + dto.Failure = ToProto(result.Failure); + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static BrowseNodeResult FromProto(BrowseNodeResultDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new BrowseNodeResult( + dto.Children.Select(FromProto).ToList(), + dto.Truncated, + dto.Failure is null ? null : FromProto(dto.Failure), + NullIfEmpty(dto.ContinuationToken)); + } + + /// Projects a onto the wire. + /// The address-space node to project. + /// The wire message. + public static BrowseNodeDto ToProto(BrowseNode node) + { + ArgumentNullException.ThrowIfNull(node); + + var dto = new BrowseNodeDto + { + NodeId = node.NodeId, + DisplayName = node.DisplayName, + NodeClass = ToProto(node.NodeClass), + HasChildren = node.HasChildren, + DataType = OrEmpty(node.DataType) + }; + + if (node.ValueRank.HasValue) + { + dto.ValueRank = node.ValueRank.Value; + } + + if (node.Writable.HasValue) + { + dto.Writable = node.Writable.Value; + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded address-space node. + public static BrowseNode FromProto(BrowseNodeDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new BrowseNode( + dto.NodeId, + dto.DisplayName, + FromProto(dto.NodeClass), + dto.HasChildren, + NullIfEmpty(dto.DataType), + dto.ValueRank, + dto.Writable); + } + + /// Projects a onto the wire. + /// The structured browse failure to project. + /// The wire message. + public static BrowseFailureDto ToProto(BrowseFailure failure) + { + ArgumentNullException.ThrowIfNull(failure); + + return new BrowseFailureDto { Kind = ToProto(failure.Kind), Message = failure.Message }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded structured browse failure. + public static BrowseFailure FromProto(BrowseFailureDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new BrowseFailure(FromProto(dto.Kind), dto.Message); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static SearchAddressSpaceResultDto ToProto(SearchAddressSpaceResult result) + { + ArgumentNullException.ThrowIfNull(result); + + var dto = new SearchAddressSpaceResultDto { CapReached = result.CapReached }; + dto.Matches.AddRange(result.Matches.Select(ToProto)); + if (result.Failure is not null) + { + dto.Failure = ToProto(result.Failure); + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static SearchAddressSpaceResult FromProto(SearchAddressSpaceResultDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SearchAddressSpaceResult( + dto.Matches.Select(FromProto).ToList(), + dto.CapReached, + dto.Failure is null ? null : FromProto(dto.Failure)); + } + + /// Projects an onto the wire. + /// The search match to project. + /// The wire message. + public static AddressSpaceMatchDto ToProto(AddressSpaceMatch match) + { + ArgumentNullException.ThrowIfNull(match); + + return new AddressSpaceMatchDto { Node = ToProto(match.Node), Path = match.Path }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded search match. + public static AddressSpaceMatch FromProto(AddressSpaceMatchDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new AddressSpaceMatch(FromProto(dto.Node), dto.Path); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static ReadTagValuesResultDto ToProto(ReadTagValuesResult result) + { + ArgumentNullException.ThrowIfNull(result); + + var dto = new ReadTagValuesResultDto(); + dto.Outcomes.AddRange(result.Outcomes.Select(ToProto)); + if (result.Failure is not null) + { + dto.Failure = ToProto(result.Failure); + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static ReadTagValuesResult FromProto(ReadTagValuesResultDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ReadTagValuesResult( + dto.Outcomes.Select(FromProto).ToList(), + dto.Failure is null ? null : FromProto(dto.Failure)); + } + + /// Projects a onto the wire. + /// The per-tag read outcome to project. + /// The wire message. + public static TagReadOutcomeDto ToProto(TagReadOutcome outcome) + { + ArgumentNullException.ThrowIfNull(outcome); + + return new TagReadOutcomeDto + { + TagPath = outcome.TagPath, + Success = outcome.Success, + Value = LooseValueCodec.ToProtoOrNull(outcome.Value), + Quality = outcome.Quality, + Timestamp = Ts(outcome.Timestamp), + ErrorMessage = OrEmpty(outcome.ErrorMessage) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded per-tag read outcome. + public static TagReadOutcome FromProto(TagReadOutcomeDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new TagReadOutcome( + dto.TagPath, + dto.Success, + LooseValueCodec.FromProto(dto.Value), + dto.Quality, + Dto(dto.Timestamp), + NullIfEmpty(dto.ErrorMessage)); + } + + /// Projects a onto the wire. + /// The connection-level read failure to project. + /// The wire message. + public static ReadTagValuesFailureDto ToProto(ReadTagValuesFailure failure) + { + ArgumentNullException.ThrowIfNull(failure); + + return new ReadTagValuesFailureDto { Kind = ToProto(failure.Kind), Message = failure.Message }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded connection-level read failure. + public static ReadTagValuesFailure FromProto(ReadTagValuesFailureDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ReadTagValuesFailure(FromProto(dto.Kind), dto.Message); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static VerifyEndpointResultDto ToProto(VerifyEndpointResult result) + { + ArgumentNullException.ThrowIfNull(result); + + var dto = new VerifyEndpointResultDto + { + Success = result.Success, + Error = OrEmpty(result.Error) + }; + + if (result.FailureKind.HasValue) + { + dto.FailureKind = new VerifyFailureKindValue { Value = ToProto(result.FailureKind.Value) }; + } + + if (result.Cert is not null) + { + dto.Cert = ToProto(result.Cert); + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static VerifyEndpointResult FromProto(VerifyEndpointResultDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new VerifyEndpointResult( + dto.Success, + dto.FailureKind is null ? null : FromProto(dto.FailureKind.Value), + NullIfEmpty(dto.Error), + dto.Cert is null ? null : FromProto(dto.Cert)); + } + + /// Projects a onto the wire. + /// The captured server certificate to project. + /// The wire message. + public static ServerCertInfoDto ToProto(ServerCertInfo cert) + { + ArgumentNullException.ThrowIfNull(cert); + + return new ServerCertInfoDto + { + Thumbprint = cert.Thumbprint, + Subject = cert.Subject, + Issuer = cert.Issuer, + NotBeforeUtc = TsUtc(cert.NotBeforeUtc), + NotAfterUtc = TsUtc(cert.NotAfterUtc), + DerBase64 = cert.DerBase64 + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded captured server certificate. + public static ServerCertInfo FromProto(ServerCertInfoDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ServerCertInfo( + dto.Thumbprint, + dto.Subject, + dto.Issuer, + DtUtc(dto.NotBeforeUtc), + DtUtc(dto.NotAfterUtc), + dto.DerBase64); + } + + /// Projects a onto the wire. + /// A null (trust/remove) leaves the list wrapper unset. + /// The reply to project. + /// The wire message. + public static CertTrustResultDto ToProto(CertTrustResult result) + { + ArgumentNullException.ThrowIfNull(result); + + var dto = new CertTrustResultDto { Success = result.Success, Error = OrEmpty(result.Error) }; + if (result.Certs is not null) + { + var list = new TrustedCertInfoListDto(); + list.Items.AddRange(result.Certs.Select(ToProto)); + dto.Certs = list; + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static CertTrustResult FromProto(CertTrustResultDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new CertTrustResult( + dto.Success, + NullIfEmpty(dto.Error), + dto.Certs is null ? null : dto.Certs.Items.Select(FromProto).ToList()); + } + + /// Projects a onto the wire. + /// The PKI store entry to project. + /// The wire message. + public static TrustedCertInfoDto ToProto(TrustedCertInfo cert) + { + ArgumentNullException.ThrowIfNull(cert); + + return new TrustedCertInfoDto + { + Thumbprint = cert.Thumbprint, + Subject = cert.Subject, + Issuer = cert.Issuer, + NotBeforeUtc = TsUtc(cert.NotBeforeUtc), + NotAfterUtc = TsUtc(cert.NotAfterUtc), + Rejected = cert.Rejected + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded PKI store entry. + public static TrustedCertInfo FromProto(TrustedCertInfoDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new TrustedCertInfo( + dto.Thumbprint, + dto.Subject, + dto.Issuer, + DtUtc(dto.NotBeforeUtc), + DtUtc(dto.NotAfterUtc), + dto.Rejected); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static WriteTagResponseDto ToProto(WriteTagResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new WriteTagResponseDto + { + CorrelationId = response.CorrelationId, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static WriteTagResponse FromProto(WriteTagResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new WriteTagResponse( + dto.CorrelationId, dto.Success, NullIfEmpty(dto.ErrorMessage), Dto(dto.Timestamp)); + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 3 — ExecuteQuery: envelopes + // ───────────────────────────────────────────────────────────────────── + + /// Packs a query-group command into its request envelope. + /// One of the four query-group commands. + /// The populated request envelope. + /// The command does not belong to this group. + public static QueryRequest ToQueryRequest(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + EventLogQueryRequest c => new QueryRequest { EventLogQuery = ToProto(c) }, + DebugSnapshotRequest c => new QueryRequest { DebugSnapshot = ToProto(c) }, + SubscribeDebugViewRequest c => new QueryRequest { SubscribeDebugView = ToProto(c) }, + UnsubscribeDebugViewRequest c => new QueryRequest { UnsubscribeDebugView = ToProto(c) }, + _ => throw NotInGroup(command, SiteCommandGroup.Query) + }; + } + + /// Unpacks a query-group request envelope back to its command record. + /// The request envelope received on the wire. + /// The decoded command record. + /// The envelope carries no case this build knows. + public static object FromQueryRequest(QueryRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return request.CommandCase switch + { + QueryRequest.CommandOneofCase.EventLogQuery => FromProto(request.EventLogQuery), + QueryRequest.CommandOneofCase.DebugSnapshot => FromProto(request.DebugSnapshot), + QueryRequest.CommandOneofCase.SubscribeDebugView => FromProto(request.SubscribeDebugView), + QueryRequest.CommandOneofCase.UnsubscribeDebugView => FromProto(request.UnsubscribeDebugView), + _ => throw UnknownCase(request.CommandCase, nameof(QueryRequest)) + }; + } + + /// + /// Packs a query-group reply into its reply envelope. Pass + /// for the unsubscribe path, which is a + /// Tell today and carries no payload. + /// + /// One of the query-group reply records. + /// The populated reply envelope. + /// The reply does not belong to this group. + public static QueryReply ToQueryReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + EventLogQueryResponse r => new QueryReply { EventLogQuery = ToProto(r) }, + DebugViewSnapshot r => new QueryReply { DebugViewSnapshot = ToProto(r) }, + UnsubscribeDebugViewAck => new QueryReply { UnsubscribeDebugView = new UnsubscribeDebugViewAckDto() }, + _ => throw NotInGroup(reply, SiteCommandGroup.Query) + }; + } + + /// Unpacks a query-group reply envelope back to its reply record. + /// The reply envelope received on the wire. + /// The decoded reply record. + /// The envelope carries no case this build knows. + public static object FromQueryReply(QueryReply reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply.ReplyCase switch + { + QueryReply.ReplyOneofCase.EventLogQuery => FromProto(reply.EventLogQuery), + QueryReply.ReplyOneofCase.DebugViewSnapshot => FromProto(reply.DebugViewSnapshot), + QueryReply.ReplyOneofCase.UnsubscribeDebugView => UnsubscribeDebugViewAck.Instance, + _ => throw UnknownCase(reply.ReplyCase, nameof(QueryReply)) + }; + } + + // ── Query commands ── + + /// Projects an onto the wire. + /// The request to project. + /// The wire message. + public static EventLogQueryRequestDto ToProto(EventLogQueryRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + var dto = new EventLogQueryRequestDto + { + CorrelationId = request.CorrelationId, + SiteId = request.SiteId, + EventType = OrEmpty(request.EventType), + Severity = OrEmpty(request.Severity), + InstanceId = OrEmpty(request.InstanceId), + KeywordFilter = OrEmpty(request.KeywordFilter), + ContinuationToken = OrEmpty(request.ContinuationToken), + PageSize = request.PageSize, + Timestamp = Ts(request.Timestamp) + }; + + if (request.From.HasValue) + { + dto.From = Ts(request.From.Value); + } + + if (request.To.HasValue) + { + dto.To = Ts(request.To.Value); + } + + return dto; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded request record. + public static EventLogQueryRequest FromProto(EventLogQueryRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new EventLogQueryRequest( + dto.CorrelationId, + dto.SiteId, + DtoOrNull(dto.From), + DtoOrNull(dto.To), + NullIfEmpty(dto.EventType), + NullIfEmpty(dto.Severity), + NullIfEmpty(dto.InstanceId), + NullIfEmpty(dto.KeywordFilter), + NullIfEmpty(dto.ContinuationToken), + dto.PageSize, + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static DebugSnapshotRequestDto ToProto(DebugSnapshotRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new DebugSnapshotRequestDto + { + InstanceUniqueName = request.InstanceUniqueName, + CorrelationId = request.CorrelationId + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static DebugSnapshotRequest FromProto(DebugSnapshotRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DebugSnapshotRequest(dto.InstanceUniqueName, dto.CorrelationId); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static SubscribeDebugViewRequestDto ToProto(SubscribeDebugViewRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new SubscribeDebugViewRequestDto + { + InstanceUniqueName = request.InstanceUniqueName, + CorrelationId = request.CorrelationId + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static SubscribeDebugViewRequest FromProto(SubscribeDebugViewRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SubscribeDebugViewRequest(dto.InstanceUniqueName, dto.CorrelationId); + } + + /// Projects an onto the wire. + /// The request to project. + /// The wire message. + public static UnsubscribeDebugViewRequestDto ToProto(UnsubscribeDebugViewRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new UnsubscribeDebugViewRequestDto + { + InstanceUniqueName = request.InstanceUniqueName, + CorrelationId = request.CorrelationId + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded request record. + public static UnsubscribeDebugViewRequest FromProto(UnsubscribeDebugViewRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new UnsubscribeDebugViewRequest(dto.InstanceUniqueName, dto.CorrelationId); + } + + // ── Query replies ── + + /// Projects an onto the wire. + /// The reply to project. + /// The wire message. + public static EventLogQueryResponseDto ToProto(EventLogQueryResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + var dto = new EventLogQueryResponseDto + { + CorrelationId = response.CorrelationId, + SiteId = response.SiteId, + ContinuationToken = OrEmpty(response.ContinuationToken), + HasMore = response.HasMore, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + dto.Entries.AddRange(response.Entries.Select(ToProto)); + return dto; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static EventLogQueryResponse FromProto(EventLogQueryResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new EventLogQueryResponse( + dto.CorrelationId, + dto.SiteId, + dto.Entries.Select(FromProto).ToList(), + NullIfEmpty(dto.ContinuationToken), + dto.HasMore, + dto.Success, + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects an onto the wire. + /// The event-log row to project. + /// The wire message. + public static EventLogEntryDto ToProto(EventLogEntry entry) + { + ArgumentNullException.ThrowIfNull(entry); + + return new EventLogEntryDto + { + Id = entry.Id, + Timestamp = Ts(entry.Timestamp), + EventType = entry.EventType, + Severity = entry.Severity, + InstanceId = OrEmpty(entry.InstanceId), + Source = entry.Source, + Message = entry.Message, + Details = OrEmpty(entry.Details) + }; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded event-log row. + public static EventLogEntry FromProto(EventLogEntryDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new EventLogEntry( + dto.Id, + Dto(dto.Timestamp), + dto.EventType, + dto.Severity, + NullIfEmpty(dto.InstanceId), + dto.Source, + dto.Message, + NullIfEmpty(dto.Details)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static DebugViewSnapshotDto ToProto(DebugViewSnapshot snapshot) + { + ArgumentNullException.ThrowIfNull(snapshot); + + var dto = new DebugViewSnapshotDto + { + InstanceUniqueName = snapshot.InstanceUniqueName, + SnapshotTimestamp = Ts(snapshot.SnapshotTimestamp), + InstanceNotFound = snapshot.InstanceNotFound + }; + dto.AttributeValues.AddRange(snapshot.AttributeValues.Select(ToProto)); + dto.AlarmStates.AddRange(snapshot.AlarmStates.Select(ToProto)); + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static DebugViewSnapshot FromProto(DebugViewSnapshotDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DebugViewSnapshot( + dto.InstanceUniqueName, + dto.AttributeValues.Select(FromProto).ToList(), + dto.AlarmStates.Select(FromProto).ToList(), + Dto(dto.SnapshotTimestamp), + dto.InstanceNotFound); + } + + /// Projects an snapshot row onto the wire. + /// The attribute snapshot row to project. + /// The wire message. + public static DebugAttributeValueDto ToProto(AttributeValueChanged value) + { + ArgumentNullException.ThrowIfNull(value); + + return new DebugAttributeValueDto + { + InstanceUniqueName = value.InstanceUniqueName, + AttributePath = value.AttributePath, + AttributeName = value.AttributeName, + Value = LooseValueCodec.ToProtoOrNull(value.Value), + Quality = value.Quality, + Timestamp = Ts(value.Timestamp) + }; + } + + /// Rehydrates an snapshot row from the wire. + /// The wire message to decode. + /// The decoded attribute snapshot row. + public static AttributeValueChanged FromProto(DebugAttributeValueDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new AttributeValueChanged( + dto.InstanceUniqueName, + dto.AttributePath, + dto.AttributeName, + LooseValueCodec.FromProto(dto.Value), + dto.Quality, + Dto(dto.Timestamp)); + } + + /// Projects an snapshot row onto the wire. + /// + /// is only written when it differs + /// from the value the record itself derives from State + Priority. + /// The record stores the condition in a nullable backing field and synthesises + /// the computed default on read, so writing it unconditionally would turn an + /// implicit condition into an explicit one — indistinguishable through the + /// property, but a difference under record equality. Omitting the redundant + /// value keeps the round trip exact for computed alarms, which are the common + /// case, and is information-preserving for the rest. + /// + /// The alarm snapshot row to project. + /// The wire message. + public static DebugAlarmStateDto ToProto(AlarmStateChanged alarm) + { + ArgumentNullException.ThrowIfNull(alarm); + + var dto = new DebugAlarmStateDto + { + InstanceUniqueName = alarm.InstanceUniqueName, + AlarmName = alarm.AlarmName, + State = ToProto(alarm.State), + Priority = alarm.Priority, + Timestamp = Ts(alarm.Timestamp), + Level = ToProto(alarm.Level), + Message = alarm.Message, + Kind = ToProto(alarm.Kind), + SourceReference = alarm.SourceReference, + AlarmTypeName = alarm.AlarmTypeName, + Category = alarm.Category, + OperatorUser = alarm.OperatorUser, + OperatorComment = alarm.OperatorComment, + CurrentValue = alarm.CurrentValue, + LimitValue = alarm.LimitValue, + NativeSourceCanonicalName = alarm.NativeSourceCanonicalName, + IsConfiguredPlaceholder = alarm.IsConfiguredPlaceholder + }; + + if (alarm.Condition != AlarmConditionStateFactory.ForComputed(alarm.State, alarm.Priority)) + { + dto.Condition = ToProto(alarm.Condition); + } + + if (alarm.OriginalRaiseTime.HasValue) + { + dto.OriginalRaiseTime = Ts(alarm.OriginalRaiseTime.Value); + } + + return dto; + } + + /// Rehydrates an snapshot row from the wire. + /// The wire message to decode. + /// The decoded alarm snapshot row. + public static AlarmStateChanged FromProto(DebugAlarmStateDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + var alarm = new AlarmStateChanged( + dto.InstanceUniqueName, + dto.AlarmName, + FromProto(dto.State), + dto.Priority, + Dto(dto.Timestamp)) + { + Level = FromProto(dto.Level), + Message = dto.Message, + Kind = FromProto(dto.Kind), + SourceReference = dto.SourceReference, + AlarmTypeName = dto.AlarmTypeName, + Category = dto.Category, + OperatorUser = dto.OperatorUser, + OperatorComment = dto.OperatorComment, + OriginalRaiseTime = DtoOrNull(dto.OriginalRaiseTime), + CurrentValue = dto.CurrentValue, + LimitValue = dto.LimitValue, + NativeSourceCanonicalName = dto.NativeSourceCanonicalName, + IsConfiguredPlaceholder = dto.IsConfiguredPlaceholder + }; + + return dto.Condition is null ? alarm : alarm with { Condition = FromProto(dto.Condition) }; + } + + /// Projects an onto the wire. + /// The unified alarm condition to project. + /// The wire message. + public static AlarmConditionStateDto ToProto(AlarmConditionState condition) + { + ArgumentNullException.ThrowIfNull(condition); + + var dto = new AlarmConditionStateDto + { + Active = condition.Active, + Acknowledged = condition.Acknowledged, + Shelve = ToProto(condition.Shelve), + Suppressed = condition.Suppressed, + Severity = condition.Severity + }; + + if (condition.Confirmed.HasValue) + { + dto.Confirmed = condition.Confirmed.Value; + } + + return dto; + } + + /// Rehydrates an from the wire. + /// The wire message to decode. + /// The decoded unified alarm condition. + public static AlarmConditionState FromProto(AlarmConditionStateDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new AlarmConditionState( + dto.Active, + dto.Acknowledged, + dto.Confirmed, + FromProto(dto.Shelve), + dto.Suppressed, + dto.Severity); + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 4 — ExecuteParked: envelopes + // ───────────────────────────────────────────────────────────────────── + + /// Packs a parked-group command into its request envelope. + /// One of the five parked-group commands. + /// The populated request envelope. + /// The command does not belong to this group. + public static ParkedRequest ToParkedRequest(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + ParkedMessageQueryRequest c => new ParkedRequest { ParkedMessageQuery = ToProto(c) }, + ParkedMessageRetryRequest c => new ParkedRequest { ParkedMessageRetry = ToProto(c) }, + ParkedMessageDiscardRequest c => new ParkedRequest { ParkedMessageDiscard = ToProto(c) }, + RetryParkedOperation c => new ParkedRequest { RetryParkedOperation = ToProto(c) }, + DiscardParkedOperation c => new ParkedRequest { DiscardParkedOperation = ToProto(c) }, + _ => throw NotInGroup(command, SiteCommandGroup.Parked) + }; + } + + /// Unpacks a parked-group request envelope back to its command record. + /// The request envelope received on the wire. + /// The decoded command record. + /// The envelope carries no case this build knows. + public static object FromParkedRequest(ParkedRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return request.CommandCase switch + { + ParkedRequest.CommandOneofCase.ParkedMessageQuery => FromProto(request.ParkedMessageQuery), + ParkedRequest.CommandOneofCase.ParkedMessageRetry => FromProto(request.ParkedMessageRetry), + ParkedRequest.CommandOneofCase.ParkedMessageDiscard => FromProto(request.ParkedMessageDiscard), + ParkedRequest.CommandOneofCase.RetryParkedOperation => FromProto(request.RetryParkedOperation), + ParkedRequest.CommandOneofCase.DiscardParkedOperation => FromProto(request.DiscardParkedOperation), + _ => throw UnknownCase(request.CommandCase, nameof(ParkedRequest)) + }; + } + + /// Packs a parked-group reply into its reply envelope. + /// One of the four parked-group reply records. + /// The populated reply envelope. + /// The reply does not belong to this group. + public static ParkedReply ToParkedReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + ParkedMessageQueryResponse r => new ParkedReply { ParkedMessageQuery = ToProto(r) }, + ParkedMessageRetryResponse r => new ParkedReply { ParkedMessageRetry = ToProto(r) }, + ParkedMessageDiscardResponse r => new ParkedReply { ParkedMessageDiscard = ToProto(r) }, + ParkedOperationActionAck r => new ParkedReply { ParkedOperationAction = ToProto(r) }, + _ => throw NotInGroup(reply, SiteCommandGroup.Parked) + }; + } + + /// Unpacks a parked-group reply envelope back to its reply record. + /// The reply envelope received on the wire. + /// The decoded reply record. + /// The envelope carries no case this build knows. + public static object FromParkedReply(ParkedReply reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply.ReplyCase switch + { + ParkedReply.ReplyOneofCase.ParkedMessageQuery => FromProto(reply.ParkedMessageQuery), + ParkedReply.ReplyOneofCase.ParkedMessageRetry => FromProto(reply.ParkedMessageRetry), + ParkedReply.ReplyOneofCase.ParkedMessageDiscard => FromProto(reply.ParkedMessageDiscard), + ParkedReply.ReplyOneofCase.ParkedOperationAction => FromProto(reply.ParkedOperationAction), + _ => throw UnknownCase(reply.ReplyCase, nameof(ParkedReply)) + }; + } + + // ── Parked commands ── + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static ParkedMessageQueryRequestDto ToProto(ParkedMessageQueryRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new ParkedMessageQueryRequestDto + { + CorrelationId = request.CorrelationId, + SiteId = request.SiteId, + PageNumber = request.PageNumber, + PageSize = request.PageSize, + Timestamp = Ts(request.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static ParkedMessageQueryRequest FromProto(ParkedMessageQueryRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageQueryRequest( + dto.CorrelationId, dto.SiteId, dto.PageNumber, dto.PageSize, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static ParkedMessageRetryRequestDto ToProto(ParkedMessageRetryRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new ParkedMessageRetryRequestDto + { + CorrelationId = request.CorrelationId, + SiteId = request.SiteId, + MessageId = request.MessageId, + Timestamp = Ts(request.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static ParkedMessageRetryRequest FromProto(ParkedMessageRetryRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageRetryRequest( + dto.CorrelationId, dto.SiteId, dto.MessageId, Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static ParkedMessageDiscardRequestDto ToProto(ParkedMessageDiscardRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new ParkedMessageDiscardRequestDto + { + CorrelationId = request.CorrelationId, + SiteId = request.SiteId, + MessageId = request.MessageId, + Timestamp = Ts(request.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static ParkedMessageDiscardRequest FromProto(ParkedMessageDiscardRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageDiscardRequest( + dto.CorrelationId, dto.SiteId, dto.MessageId, Dto(dto.Timestamp)); + } + + /// Projects a relay onto the wire. + /// The relay command to project. + /// The wire message. + public static RetryParkedOperationDto ToProto(RetryParkedOperation command) + { + ArgumentNullException.ThrowIfNull(command); + + return new RetryParkedOperationDto + { + CorrelationId = command.CorrelationId, + TrackedOperationId = command.TrackedOperationId.ToString() + }; + } + + /// Rehydrates a relay from the wire. + /// The wire message to decode. + /// The decoded relay command. + public static RetryParkedOperation FromProto(RetryParkedOperationDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RetryParkedOperation(dto.CorrelationId, TrackedId(dto.TrackedOperationId)); + } + + /// Projects a relay onto the wire. + /// The relay command to project. + /// The wire message. + public static DiscardParkedOperationDto ToProto(DiscardParkedOperation command) + { + ArgumentNullException.ThrowIfNull(command); + + return new DiscardParkedOperationDto + { + CorrelationId = command.CorrelationId, + TrackedOperationId = command.TrackedOperationId.ToString() + }; + } + + /// Rehydrates a relay from the wire. + /// The wire message to decode. + /// The decoded relay command. + public static DiscardParkedOperation FromProto(DiscardParkedOperationDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new DiscardParkedOperation(dto.CorrelationId, TrackedId(dto.TrackedOperationId)); + } + + // ── Parked replies ── + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static ParkedMessageQueryResponseDto ToProto(ParkedMessageQueryResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + var dto = new ParkedMessageQueryResponseDto + { + CorrelationId = response.CorrelationId, + SiteId = response.SiteId, + TotalCount = response.TotalCount, + PageNumber = response.PageNumber, + PageSize = response.PageSize, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + dto.Messages.AddRange(response.Messages.Select(ToProto)); + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static ParkedMessageQueryResponse FromProto(ParkedMessageQueryResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageQueryResponse( + dto.CorrelationId, + dto.SiteId, + dto.Messages.Select(FromProto).ToList(), + dto.TotalCount, + dto.PageNumber, + dto.PageSize, + dto.Success, + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The parked store-and-forward row to project. + /// The wire message. + public static ParkedMessageEntryDto ToProto(ParkedMessageEntry entry) + { + ArgumentNullException.ThrowIfNull(entry); + + return new ParkedMessageEntryDto + { + MessageId = entry.MessageId, + TargetSystem = entry.TargetSystem, + MethodName = entry.MethodName, + ErrorMessage = entry.ErrorMessage, + AttemptCount = entry.AttemptCount, + OriginalTimestamp = Ts(entry.OriginalTimestamp), + LastAttemptTimestamp = Ts(entry.LastAttemptTimestamp), + MaxAttempts = entry.MaxAttempts, + Category = ToProto(entry.Category), + OriginInstance = OrEmpty(entry.OriginInstance) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded parked store-and-forward row. + public static ParkedMessageEntry FromProto(ParkedMessageEntryDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageEntry( + dto.MessageId, + dto.TargetSystem, + dto.MethodName, + dto.ErrorMessage, + dto.AttemptCount, + Dto(dto.OriginalTimestamp), + Dto(dto.LastAttemptTimestamp), + dto.MaxAttempts, + FromProto(dto.Category), + NullIfEmpty(dto.OriginInstance)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static ParkedMessageRetryResponseDto ToProto(ParkedMessageRetryResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new ParkedMessageRetryResponseDto + { + CorrelationId = response.CorrelationId, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static ParkedMessageRetryResponse FromProto(ParkedMessageRetryResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageRetryResponse(dto.CorrelationId, dto.Success, NullIfEmpty(dto.ErrorMessage)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static ParkedMessageDiscardResponseDto ToProto(ParkedMessageDiscardResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new ParkedMessageDiscardResponseDto + { + CorrelationId = response.CorrelationId, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static ParkedMessageDiscardResponse FromProto(ParkedMessageDiscardResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedMessageDiscardResponse(dto.CorrelationId, dto.Success, NullIfEmpty(dto.ErrorMessage)); + } + + /// Projects a onto the wire. + /// The relay ack to project. + /// The wire message. + public static ParkedOperationActionAckDto ToProto(ParkedOperationActionAck ack) + { + ArgumentNullException.ThrowIfNull(ack); + + return new ParkedOperationActionAckDto + { + CorrelationId = ack.CorrelationId, + Applied = ack.Applied, + ErrorMessage = OrEmpty(ack.ErrorMessage) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded relay ack. + public static ParkedOperationActionAck FromProto(ParkedOperationActionAckDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new ParkedOperationActionAck(dto.CorrelationId, dto.Applied, NullIfEmpty(dto.ErrorMessage)); + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 5 — ExecuteRoute: envelopes + // ───────────────────────────────────────────────────────────────────── + + /// Packs a route-group command into its request envelope. + /// One of the four route-group commands. + /// The populated request envelope. + /// The command does not belong to this group. + public static RouteRequest ToRouteRequest(object command) + { + ArgumentNullException.ThrowIfNull(command); + + return command switch + { + RouteToCallRequest c => new RouteRequest { RouteToCall = ToProto(c) }, + RouteToGetAttributesRequest c => new RouteRequest { RouteToGetAttributes = ToProto(c) }, + RouteToSetAttributesRequest c => new RouteRequest { RouteToSetAttributes = ToProto(c) }, + RouteToWaitForAttributeRequest c => new RouteRequest { RouteToWaitForAttribute = ToProto(c) }, + _ => throw NotInGroup(command, SiteCommandGroup.Route) + }; + } + + /// Unpacks a route-group request envelope back to its command record. + /// The request envelope received on the wire. + /// The decoded command record. + /// The envelope carries no case this build knows. + public static object FromRouteRequest(RouteRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return request.CommandCase switch + { + RouteRequest.CommandOneofCase.RouteToCall => FromProto(request.RouteToCall), + RouteRequest.CommandOneofCase.RouteToGetAttributes => FromProto(request.RouteToGetAttributes), + RouteRequest.CommandOneofCase.RouteToSetAttributes => FromProto(request.RouteToSetAttributes), + RouteRequest.CommandOneofCase.RouteToWaitForAttribute => FromProto(request.RouteToWaitForAttribute), + _ => throw UnknownCase(request.CommandCase, nameof(RouteRequest)) + }; + } + + /// Packs a route-group reply into its reply envelope. + /// One of the four route-group reply records. + /// The populated reply envelope. + /// The reply does not belong to this group. + public static RouteReply ToRouteReply(object reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply switch + { + RouteToCallResponse r => new RouteReply { RouteToCall = ToProto(r) }, + RouteToGetAttributesResponse r => new RouteReply { RouteToGetAttributes = ToProto(r) }, + RouteToSetAttributesResponse r => new RouteReply { RouteToSetAttributes = ToProto(r) }, + RouteToWaitForAttributeResponse r => new RouteReply { RouteToWaitForAttribute = ToProto(r) }, + _ => throw NotInGroup(reply, SiteCommandGroup.Route) + }; + } + + /// Unpacks a route-group reply envelope back to its reply record. + /// The reply envelope received on the wire. + /// The decoded reply record. + /// The envelope carries no case this build knows. + public static object FromRouteReply(RouteReply reply) + { + ArgumentNullException.ThrowIfNull(reply); + + return reply.ReplyCase switch + { + RouteReply.ReplyOneofCase.RouteToCall => FromProto(reply.RouteToCall), + RouteReply.ReplyOneofCase.RouteToGetAttributes => FromProto(reply.RouteToGetAttributes), + RouteReply.ReplyOneofCase.RouteToSetAttributes => FromProto(reply.RouteToSetAttributes), + RouteReply.ReplyOneofCase.RouteToWaitForAttribute => FromProto(reply.RouteToWaitForAttribute), + _ => throw UnknownCase(reply.ReplyCase, nameof(RouteReply)) + }; + } + + // ── Route commands ── + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static RouteToCallRequestDto ToProto(RouteToCallRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + return new RouteToCallRequestDto + { + CorrelationId = request.CorrelationId, + InstanceUniqueName = request.InstanceUniqueName, + ScriptName = request.ScriptName, + Parameters = LooseValueCodec.ToProtoMapOrNull(request.Parameters), + Timestamp = Ts(request.Timestamp), + ParentExecutionId = GuidToWire(request.ParentExecutionId) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static RouteToCallRequest FromProto(RouteToCallRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToCallRequest( + dto.CorrelationId, + dto.InstanceUniqueName, + dto.ScriptName, + LooseValueCodec.FromProtoMapOrNull(dto.Parameters), + Dto(dto.Timestamp), + GuidFromWire(dto.ParentExecutionId)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static RouteToGetAttributesRequestDto ToProto(RouteToGetAttributesRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + var dto = new RouteToGetAttributesRequestDto + { + CorrelationId = request.CorrelationId, + InstanceUniqueName = request.InstanceUniqueName, + Timestamp = Ts(request.Timestamp), + ParentExecutionId = GuidToWire(request.ParentExecutionId) + }; + dto.AttributeNames.AddRange(request.AttributeNames); + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static RouteToGetAttributesRequest FromProto(RouteToGetAttributesRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToGetAttributesRequest( + dto.CorrelationId, + dto.InstanceUniqueName, + dto.AttributeNames.ToList(), + Dto(dto.Timestamp), + GuidFromWire(dto.ParentExecutionId)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static RouteToSetAttributesRequestDto ToProto(RouteToSetAttributesRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + var dto = new RouteToSetAttributesRequestDto + { + CorrelationId = request.CorrelationId, + InstanceUniqueName = request.InstanceUniqueName, + Timestamp = Ts(request.Timestamp), + ParentExecutionId = GuidToWire(request.ParentExecutionId) + }; + + foreach (var (key, value) in request.AttributeValues) + { + dto.AttributeValues[key] = value; + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static RouteToSetAttributesRequest FromProto(RouteToSetAttributesRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToSetAttributesRequest( + dto.CorrelationId, + dto.InstanceUniqueName, + dto.AttributeValues.ToDictionary(kv => kv.Key, kv => kv.Value), + Dto(dto.Timestamp), + GuidFromWire(dto.ParentExecutionId)); + } + + /// Projects a onto the wire. + /// The request to project. + /// The wire message. + public static RouteToWaitForAttributeRequestDto ToProto(RouteToWaitForAttributeRequest request) + { + ArgumentNullException.ThrowIfNull(request); + + var dto = new RouteToWaitForAttributeRequestDto + { + CorrelationId = request.CorrelationId, + InstanceUniqueName = request.InstanceUniqueName, + AttributeName = request.AttributeName, + Timeout = Duration.FromTimeSpan(request.Timeout), + Timestamp = Ts(request.Timestamp), + ParentExecutionId = GuidToWire(request.ParentExecutionId), + RequireGoodQuality = request.RequireGoodQuality + }; + + if (request.TargetValueEncoded is not null) + { + dto.TargetValueEncoded = request.TargetValueEncoded; + } + + return dto; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded request record. + public static RouteToWaitForAttributeRequest FromProto(RouteToWaitForAttributeRequestDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToWaitForAttributeRequest( + dto.CorrelationId, + dto.InstanceUniqueName, + dto.AttributeName, + dto.TargetValueEncoded, + dto.Timeout?.ToTimeSpan() ?? TimeSpan.Zero, + Dto(dto.Timestamp), + GuidFromWire(dto.ParentExecutionId), + dto.RequireGoodQuality); + } + + // ── Route replies ── + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static RouteToCallResponseDto ToProto(RouteToCallResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new RouteToCallResponseDto + { + CorrelationId = response.CorrelationId, + Success = response.Success, + ReturnValue = LooseValueCodec.ToProtoOrNull(response.ReturnValue), + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static RouteToCallResponse FromProto(RouteToCallResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToCallResponse( + dto.CorrelationId, + dto.Success, + LooseValueCodec.FromProto(dto.ReturnValue), + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static RouteToGetAttributesResponseDto ToProto(RouteToGetAttributesResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new RouteToGetAttributesResponseDto + { + CorrelationId = response.CorrelationId, + Values = LooseValueCodec.ToProtoMap(response.Values), + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static RouteToGetAttributesResponse FromProto(RouteToGetAttributesResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToGetAttributesResponse( + dto.CorrelationId, + LooseValueCodec.FromProtoMap(dto.Values), + dto.Success, + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static RouteToSetAttributesResponseDto ToProto(RouteToSetAttributesResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new RouteToSetAttributesResponseDto + { + CorrelationId = response.CorrelationId, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static RouteToSetAttributesResponse FromProto(RouteToSetAttributesResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToSetAttributesResponse( + dto.CorrelationId, dto.Success, NullIfEmpty(dto.ErrorMessage), Dto(dto.Timestamp)); + } + + /// Projects a onto the wire. + /// The reply to project. + /// The wire message. + public static RouteToWaitForAttributeResponseDto ToProto(RouteToWaitForAttributeResponse response) + { + ArgumentNullException.ThrowIfNull(response); + + return new RouteToWaitForAttributeResponseDto + { + CorrelationId = response.CorrelationId, + Matched = response.Matched, + Value = LooseValueCodec.ToProtoOrNull(response.Value), + Quality = OrEmpty(response.Quality), + TimedOut = response.TimedOut, + Success = response.Success, + ErrorMessage = OrEmpty(response.ErrorMessage), + Timestamp = Ts(response.Timestamp) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded reply record. + public static RouteToWaitForAttributeResponse FromProto(RouteToWaitForAttributeResponseDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new RouteToWaitForAttributeResponse( + dto.CorrelationId, + dto.Matched, + LooseValueCodec.FromProto(dto.Value), + NullIfEmpty(dto.Quality), + dto.TimedOut, + dto.Success, + NullIfEmpty(dto.ErrorMessage), + Dto(dto.Timestamp)); + } + + // ───────────────────────────────────────────────────────────────────── + // RPC 6 — TriggerFailover + // ───────────────────────────────────────────────────────────────────── + + /// Projects a onto the wire. + /// The relay command to project. + /// The wire message. + public static TriggerSiteFailoverDto ToProto(TriggerSiteFailover command) + { + ArgumentNullException.ThrowIfNull(command); + + return new TriggerSiteFailoverDto + { + CorrelationId = command.CorrelationId, + SiteId = command.SiteId + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded relay command. + public static TriggerSiteFailover FromProto(TriggerSiteFailoverDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new TriggerSiteFailover(dto.CorrelationId, dto.SiteId); + } + + /// Projects a onto the wire. + /// The relay ack to project. + /// The wire message. + public static SiteFailoverAckDto ToProto(SiteFailoverAck ack) + { + ArgumentNullException.ThrowIfNull(ack); + + return new SiteFailoverAckDto + { + CorrelationId = ack.CorrelationId, + Accepted = ack.Accepted, + TargetAddress = OrEmpty(ack.TargetAddress), + ErrorMessage = OrEmpty(ack.ErrorMessage) + }; + } + + /// Rehydrates a from the wire. + /// The wire message to decode. + /// The decoded relay ack. + public static SiteFailoverAck FromProto(SiteFailoverAckDto dto) + { + ArgumentNullException.ThrowIfNull(dto); + + return new SiteFailoverAck( + dto.CorrelationId, + dto.Accepted, + NullIfEmpty(dto.TargetAddress), + NullIfEmpty(dto.ErrorMessage)); + } + + // ───────────────────────────────────────────────────────────────────── + // Enum translation — explicit both ways, never by ordinal. + // ───────────────────────────────────────────────────────────────────── + + /// Projects a onto its wire enum. + /// The status to project. + /// The wire enum value. + public static DeploymentStatusDto ToProto(DeploymentStatus status) => status switch + { + DeploymentStatus.Pending => DeploymentStatusDto.Pending, + DeploymentStatus.InProgress => DeploymentStatusDto.InProgress, + DeploymentStatus.Success => DeploymentStatusDto.Success, + DeploymentStatus.Failed => DeploymentStatusDto.Failed, + _ => DeploymentStatusDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to Failed (never claim success). + /// The wire enum value. + /// The decoded status. + public static DeploymentStatus FromProto(DeploymentStatusDto status) => status switch + { + DeploymentStatusDto.Pending => DeploymentStatus.Pending, + DeploymentStatusDto.InProgress => DeploymentStatus.InProgress, + DeploymentStatusDto.Success => DeploymentStatus.Success, + _ => DeploymentStatus.Failed + }; + + /// Projects a onto its wire enum. + /// The node class to project. + /// The wire enum value. + public static BrowseNodeClassDto ToProto(BrowseNodeClass nodeClass) => nodeClass switch + { + BrowseNodeClass.Object => BrowseNodeClassDto.Object, + BrowseNodeClass.Variable => BrowseNodeClassDto.Variable, + BrowseNodeClass.Method => BrowseNodeClassDto.Method, + BrowseNodeClass.Other => BrowseNodeClassDto.Other, + _ => BrowseNodeClassDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to Other. + /// The wire enum value. + /// The decoded node class. + public static BrowseNodeClass FromProto(BrowseNodeClassDto nodeClass) => nodeClass switch + { + BrowseNodeClassDto.Object => BrowseNodeClass.Object, + BrowseNodeClassDto.Variable => BrowseNodeClass.Variable, + BrowseNodeClassDto.Method => BrowseNodeClass.Method, + _ => BrowseNodeClass.Other + }; + + /// Projects a onto its wire enum. + /// The failure kind to project. + /// The wire enum value. + public static BrowseFailureKindDto ToProto(BrowseFailureKind kind) => kind switch + { + BrowseFailureKind.ConnectionNotFound => BrowseFailureKindDto.ConnectionNotFound, + BrowseFailureKind.ConnectionNotConnected => BrowseFailureKindDto.ConnectionNotConnected, + BrowseFailureKind.NotBrowsable => BrowseFailureKindDto.NotBrowsable, + BrowseFailureKind.Timeout => BrowseFailureKindDto.Timeout, + BrowseFailureKind.ServerError => BrowseFailureKindDto.ServerError, + _ => BrowseFailureKindDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to ServerError. + /// The wire enum value. + /// The decoded failure kind. + public static BrowseFailureKind FromProto(BrowseFailureKindDto kind) => kind switch + { + BrowseFailureKindDto.ConnectionNotFound => BrowseFailureKind.ConnectionNotFound, + BrowseFailureKindDto.ConnectionNotConnected => BrowseFailureKind.ConnectionNotConnected, + BrowseFailureKindDto.NotBrowsable => BrowseFailureKind.NotBrowsable, + BrowseFailureKindDto.Timeout => BrowseFailureKind.Timeout, + _ => BrowseFailureKind.ServerError + }; + + /// Projects a onto its wire enum. + /// The failure kind to project. + /// The wire enum value. + public static ReadTagValuesFailureKindDto ToProto(ReadTagValuesFailureKind kind) => kind switch + { + ReadTagValuesFailureKind.ConnectionNotFound => ReadTagValuesFailureKindDto.ConnectionNotFound, + ReadTagValuesFailureKind.ConnectionNotConnected => ReadTagValuesFailureKindDto.ConnectionNotConnected, + ReadTagValuesFailureKind.Timeout => ReadTagValuesFailureKindDto.Timeout, + ReadTagValuesFailureKind.ServerError => ReadTagValuesFailureKindDto.ServerError, + _ => ReadTagValuesFailureKindDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to ServerError. + /// The wire enum value. + /// The decoded failure kind. + public static ReadTagValuesFailureKind FromProto(ReadTagValuesFailureKindDto kind) => kind switch + { + ReadTagValuesFailureKindDto.ConnectionNotFound => ReadTagValuesFailureKind.ConnectionNotFound, + ReadTagValuesFailureKindDto.ConnectionNotConnected => ReadTagValuesFailureKind.ConnectionNotConnected, + ReadTagValuesFailureKindDto.Timeout => ReadTagValuesFailureKind.Timeout, + _ => ReadTagValuesFailureKind.ServerError + }; + + /// Projects a onto its wire enum. + /// The failure kind to project. + /// The wire enum value. + public static VerifyFailureKindDto ToProto(VerifyFailureKind kind) => kind switch + { + VerifyFailureKind.Unreachable => VerifyFailureKindDto.Unreachable, + VerifyFailureKind.AuthFailed => VerifyFailureKindDto.AuthFailed, + VerifyFailureKind.UntrustedCertificate => VerifyFailureKindDto.UntrustedCertificate, + VerifyFailureKind.Timeout => VerifyFailureKindDto.Timeout, + VerifyFailureKind.ServerError => VerifyFailureKindDto.ServerError, + _ => VerifyFailureKindDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to ServerError. + /// The wire enum value. + /// The decoded failure kind. + public static VerifyFailureKind FromProto(VerifyFailureKindDto kind) => kind switch + { + VerifyFailureKindDto.Unreachable => VerifyFailureKind.Unreachable, + VerifyFailureKindDto.AuthFailed => VerifyFailureKind.AuthFailed, + VerifyFailureKindDto.UntrustedCertificate => VerifyFailureKind.UntrustedCertificate, + VerifyFailureKindDto.Timeout => VerifyFailureKind.Timeout, + _ => VerifyFailureKind.ServerError + }; + + /// Projects a onto its wire enum. + /// The category to project. + /// The wire enum value. + public static StoreAndForwardCategoryDto ToProto(StoreAndForwardCategory category) => category switch + { + StoreAndForwardCategory.ExternalSystem => StoreAndForwardCategoryDto.ExternalSystem, + StoreAndForwardCategory.Notification => StoreAndForwardCategoryDto.Notification, + StoreAndForwardCategory.CachedDbWrite => StoreAndForwardCategoryDto.CachedDbWrite, + _ => StoreAndForwardCategoryDto.Unspecified + }; + + /// Rehydrates a ; unknown decodes to ExternalSystem (the DTO's own default). + /// The wire enum value. + /// The decoded category. + public static StoreAndForwardCategory FromProto(StoreAndForwardCategoryDto category) => category switch + { + StoreAndForwardCategoryDto.Notification => StoreAndForwardCategory.Notification, + StoreAndForwardCategoryDto.CachedDbWrite => StoreAndForwardCategory.CachedDbWrite, + _ => StoreAndForwardCategory.ExternalSystem + }; + + /// Projects an onto its wire enum. + /// The alarm state to project. + /// The wire enum value. + public static AlarmStateDto ToProto(AlarmState state) => state switch + { + AlarmState.Active => AlarmStateDto.Active, + AlarmState.Normal => AlarmStateDto.Normal, + _ => AlarmStateDto.Unspecified + }; + + /// Rehydrates an ; unknown decodes to Normal (never invent an alarm). + /// The wire enum value. + /// The decoded alarm state. + public static AlarmState FromProto(AlarmStateDto state) => + state == AlarmStateDto.Active ? AlarmState.Active : AlarmState.Normal; + + /// Projects an onto its wire enum. + /// The alarm level to project. + /// The wire enum value. + public static AlarmLevelDto ToProto(AlarmLevel level) => level switch + { + AlarmLevel.None => AlarmLevelDto.None, + AlarmLevel.Low => AlarmLevelDto.Low, + AlarmLevel.LowLow => AlarmLevelDto.LowLow, + AlarmLevel.High => AlarmLevelDto.High, + AlarmLevel.HighHigh => AlarmLevelDto.HighHigh, + _ => AlarmLevelDto.Unspecified + }; + + /// Rehydrates an ; unknown decodes to None. + /// The wire enum value. + /// The decoded alarm level. + public static AlarmLevel FromProto(AlarmLevelDto level) => level switch + { + AlarmLevelDto.Low => AlarmLevel.Low, + AlarmLevelDto.LowLow => AlarmLevel.LowLow, + AlarmLevelDto.High => AlarmLevel.High, + AlarmLevelDto.HighHigh => AlarmLevel.HighHigh, + _ => AlarmLevel.None + }; + + /// Projects an onto its wire enum. + /// The alarm kind to project. + /// The wire enum value. + public static AlarmKindDto ToProto(AlarmKind kind) => kind switch + { + AlarmKind.Computed => AlarmKindDto.Computed, + AlarmKind.NativeOpcUa => AlarmKindDto.NativeOpcUa, + AlarmKind.NativeMxAccess => AlarmKindDto.NativeMxAccess, + _ => AlarmKindDto.Unspecified + }; + + /// Rehydrates an ; unknown decodes to Computed (the record's own default). + /// The wire enum value. + /// The decoded alarm kind. + public static AlarmKind FromProto(AlarmKindDto kind) => kind switch + { + AlarmKindDto.NativeOpcUa => AlarmKind.NativeOpcUa, + AlarmKindDto.NativeMxAccess => AlarmKind.NativeMxAccess, + _ => AlarmKind.Computed + }; + + /// Projects an onto its wire enum. + /// The shelve state to project. + /// The wire enum value. + public static AlarmShelveStateDto ToProto(AlarmShelveState shelve) => shelve switch + { + AlarmShelveState.Unshelved => AlarmShelveStateDto.Unshelved, + AlarmShelveState.OneShotShelved => AlarmShelveStateDto.OneShotShelved, + AlarmShelveState.TimedShelved => AlarmShelveStateDto.TimedShelved, + AlarmShelveState.PermanentShelved => AlarmShelveStateDto.PermanentShelved, + _ => AlarmShelveStateDto.Unspecified + }; + + /// + /// Rehydrates an ; unknown decodes to + /// Unshelved — the same safe default + /// applies on the streaming path. + /// + /// The wire enum value. + /// The decoded shelve state. + public static AlarmShelveState FromProto(AlarmShelveStateDto shelve) => shelve switch + { + AlarmShelveStateDto.OneShotShelved => AlarmShelveState.OneShotShelved, + AlarmShelveStateDto.TimedShelved => AlarmShelveState.TimedShelved, + AlarmShelveStateDto.PermanentShelved => AlarmShelveState.PermanentShelved, + _ => AlarmShelveState.Unshelved + }; + + // ───────────────────────────────────────────────────────────────────── + // Primitive helpers + // ───────────────────────────────────────────────────────────────────── + + private static Timestamp Ts(DateTimeOffset value) => Timestamp.FromDateTimeOffset(value); + + private static DateTimeOffset Dto(Timestamp? value) => + value?.ToDateTimeOffset() ?? default; + + private static DateTimeOffset? DtoOrNull(Timestamp? value) => + value?.ToDateTimeOffset(); + + private static Timestamp TsUtc(DateTime value) => Timestamp.FromDateTime(EnsureUtc(value)); + + private static DateTime DtUtc(Timestamp? value) => value?.ToDateTime() ?? default; + + private static DateTime EnsureUtc(DateTime value) => + value.Kind == DateTimeKind.Utc + ? value + : DateTime.SpecifyKind(value.ToUniversalTime(), DateTimeKind.Utc); + + private static string OrEmpty(string? value) => value ?? string.Empty; + + private static string? NullIfEmpty(string value) => string.IsNullOrEmpty(value) ? null : value; + + private static string GuidToWire(Guid? value) => value?.ToString("D") ?? string.Empty; + + private static Guid? GuidFromWire(string value) => + Guid.TryParse(value, out var parsed) ? parsed : null; + + private static TrackedOperationId TrackedId(string value) => + TrackedOperationId.TryParse(value, out var parsed) ? parsed : default; + + private static ArgumentException NotInGroup(object message, SiteCommandGroup group) => + new($"'{message.GetType().Name}' is not part of the {group} RPC group.", nameof(message)); + + private static NotSupportedException UnknownCase(TCase oneofCase, string envelope) + where TCase : struct, Enum => + new($"{envelope} carries oneof case '{oneofCase}', which this build does not understand. " + + "The peer is running a newer contract (message evolution is additive-only)."); +} + +/// +/// Marker reply for the fire-and-forget UnsubscribeDebugView command. +/// +/// +/// The Akka path Tells the unsubscribe and expects nothing back, but a unary RPC +/// must answer something. This singleton is what the dispatcher returns and what +/// produces, so the two +/// transports present the same shape; the central transport discards it and keeps +/// the caller-visible fire-and-forget semantics. +/// +public sealed record UnsubscribeDebugViewAck +{ + private UnsubscribeDebugViewAck() + { + } + + /// The single instance. + public static UnsubscribeDebugViewAck Instance { get; } = new(); +} diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandGroup.cs b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandGroup.cs new file mode 100644 index 00000000..c422e271 --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandGroup.cs @@ -0,0 +1,33 @@ +namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc; + +/// +/// The six domain groups the 28 migrated central→site commands are partitioned +/// into — one group per SiteCommandService RPC. +/// +/// +/// The partition is not cosmetic: every command inside a group shares a +/// DEADLINE class today (the CommunicationOptions timeout the central +/// Ask uses), so one RPC per group keeps the deadline decision in one +/// place on the client and one dispatch switch on the server, while the +/// oneof envelope keeps each command individually typed. +/// +public enum SiteCommandGroup +{ + /// Deployment refresh, instance enable/disable/delete, deployment-state query, artifact deployment. + Lifecycle, + + /// Interactive OPC UA / MxGateway design-time commands: browse, search, read, verify, cert trust, write tag. + OpcUa, + + /// Read-only remote queries: site event log and debug view snapshot/subscribe/unsubscribe. + Query, + + /// Parked store-and-forward message actions and parked cached-operation retry/discard relays. + Parked, + + /// Inbound-API Route.To() relays: call, get/set attributes, wait for attribute. + Route, + + /// Operator-initiated manual site-pair failover. + Failover +} diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/Protos/site_command.proto b/src/ZB.MOM.WW.ScadaBridge.Communication/Protos/site_command.proto new file mode 100644 index 00000000..9f61f69c --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/Protos/site_command.proto @@ -0,0 +1,857 @@ +syntax = "proto3"; +option csharp_namespace = "ZB.MOM.WW.ScadaBridge.Communication.Grpc"; +package scadabridge.sitecommand.v1; + +import "google/protobuf/timestamp.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/wrappers.proto"; + +// ───────────────────────────────────────────────────────────────────────────── +// Site command plane (central → site) — the gRPC replacement for the per-site +// ClusterClient command/control channel handled by SiteCommunicationActor. +// +// The 28 migrated commands are grouped into six domain RPCs rather than 28 +// individual RPCs, because the grouping is what carries the DEADLINE policy: +// every command inside one group shares a timeout class today (see +// CommunicationOptions), so one RPC per group keeps the deadline choice in one +// place on the client and one dispatch switch on the server. A `oneof` request +// / reply envelope preserves per-command typing inside the group. +// +// IntegrationCallRequest (the 29th command) is deliberately NOT here — it is +// dead code at both ends; see +// docs/known-issues/2026-07-22-integration-call-routing-is-dead-code.md. +// +// EVOLUTION RULE (same as sitestream.proto): field numbers are never reused and +// changes are additive only. New commands take the next free oneof tag; an +// older peer simply sees an unset oneof and answers with a clean error. +// +// The generated C# is CHECKED IN under Communication/SiteCommandGrpc/ because +// protoc segfaults inside the linux_arm64 Docker build image. Regenerate with +// docker/regen-proto.sh (or by hand per the recipe in the .csproj) — never by +// leaving an active item in the project file. +// ───────────────────────────────────────────────────────────────────────────── + +service SiteCommandService { + // Deployment + instance lifecycle (6 commands). + rpc ExecuteLifecycle(LifecycleRequest) returns (LifecycleReply); + // Interactive OPC UA / MxGateway design-time commands (8 commands). + rpc ExecuteOpcUa(OpcUaRequest) returns (OpcUaReply); + // Remote read-only queries: event log + debug view (4 commands). + rpc ExecuteQuery(QueryRequest) returns (QueryReply); + // Parked store-and-forward message + cached-operation actions (5 commands). + rpc ExecuteParked(ParkedRequest) returns (ParkedReply); + // Inbound-API Route.To() relays (4 commands). + rpc ExecuteRoute(RouteRequest) returns (RouteReply); + // Operator-initiated manual site-pair failover (1 command). + rpc TriggerFailover(TriggerSiteFailoverDto) returns (SiteFailoverAckDto); +} + +// ───────────────────────────────────────────────────────────────────────────── +// Shared value carrier +// ───────────────────────────────────────────────────────────────────────────── + +// Explicit null marker. Needed because a map entry always +// has a value message present, so "the dictionary holds a null for this key" +// cannot be expressed by absence the way a nullable message FIELD can. +message LooseNull {} + +message LooseValueList { repeated LooseValue items = 1; } + +message LooseValueMap { map entries = 1; } + +// Type-tagged carrier for the `object?` members the command plane still uses +// (script parameters and return values, attribute values, tag read/write +// values). The tags cover every CLR type these fields actually carry, so those +// values round-trip with their runtime type intact; anything else falls back to +// `json_value` (see the mapper's documented lossiness note). +// +// Date/time and decimal ride as invariant round-trip STRINGS rather than +// google.protobuf.Timestamp: Timestamp normalises everything to UTC and would +// silently drop DateTime.Kind / DateTimeOffset.Offset, which for an operator's +// tag value is data loss, not normalisation. +message LooseValue { + oneof kind { + LooseNull null_value = 1; + bool bool_value = 2; + int32 int32_value = 3; + int64 int64_value = 4; + double double_value = 5; + float float_value = 6; + string string_value = 7; + string decimal_value = 8; // invariant-culture round-trip + string date_time_value = 9; // DateTime, "O" (preserves Kind) + string date_time_offset_value = 10; // DateTimeOffset, "O" (preserves Offset) + string guid_value = 11; // "D" + string time_span_value = 12; // "c" (constant/round-trip) + bytes bytes_value = 13; + LooseValueList list_value = 14; + LooseValueMap map_value = 15; + string json_value = 16; // fallback; decodes to JsonElement + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// Enums. Every enum reserves 0 for _UNSPECIFIED so a value that is absent on +// the wire is never mistaken for the first CLR member. The mapper translates +// explicitly in both directions (never by ordinal), so reordering a C# enum +// cannot silently re-map the wire. +// ───────────────────────────────────────────────────────────────────────────── + +enum DeploymentStatusDto { + DEPLOYMENT_STATUS_DTO_UNSPECIFIED = 0; + DEPLOYMENT_STATUS_DTO_PENDING = 1; + DEPLOYMENT_STATUS_DTO_IN_PROGRESS = 2; + DEPLOYMENT_STATUS_DTO_SUCCESS = 3; + DEPLOYMENT_STATUS_DTO_FAILED = 4; +} + +enum BrowseNodeClassDto { + BROWSE_NODE_CLASS_DTO_UNSPECIFIED = 0; + BROWSE_NODE_CLASS_DTO_OBJECT = 1; + BROWSE_NODE_CLASS_DTO_VARIABLE = 2; + BROWSE_NODE_CLASS_DTO_METHOD = 3; + BROWSE_NODE_CLASS_DTO_OTHER = 4; +} + +enum BrowseFailureKindDto { + BROWSE_FAILURE_KIND_DTO_UNSPECIFIED = 0; + BROWSE_FAILURE_KIND_DTO_CONNECTION_NOT_FOUND = 1; + BROWSE_FAILURE_KIND_DTO_CONNECTION_NOT_CONNECTED = 2; + BROWSE_FAILURE_KIND_DTO_NOT_BROWSABLE = 3; + BROWSE_FAILURE_KIND_DTO_TIMEOUT = 4; + BROWSE_FAILURE_KIND_DTO_SERVER_ERROR = 5; +} + +enum ReadTagValuesFailureKindDto { + READ_TAG_VALUES_FAILURE_KIND_DTO_UNSPECIFIED = 0; + READ_TAG_VALUES_FAILURE_KIND_DTO_CONNECTION_NOT_FOUND = 1; + READ_TAG_VALUES_FAILURE_KIND_DTO_CONNECTION_NOT_CONNECTED = 2; + READ_TAG_VALUES_FAILURE_KIND_DTO_TIMEOUT = 3; + READ_TAG_VALUES_FAILURE_KIND_DTO_SERVER_ERROR = 4; +} + +enum VerifyFailureKindDto { + VERIFY_FAILURE_KIND_DTO_UNSPECIFIED = 0; + VERIFY_FAILURE_KIND_DTO_UNREACHABLE = 1; + VERIFY_FAILURE_KIND_DTO_AUTH_FAILED = 2; + VERIFY_FAILURE_KIND_DTO_UNTRUSTED_CERTIFICATE = 3; + VERIFY_FAILURE_KIND_DTO_TIMEOUT = 4; + VERIFY_FAILURE_KIND_DTO_SERVER_ERROR = 5; +} + +enum StoreAndForwardCategoryDto { + STORE_AND_FORWARD_CATEGORY_DTO_UNSPECIFIED = 0; + STORE_AND_FORWARD_CATEGORY_DTO_EXTERNAL_SYSTEM = 1; + STORE_AND_FORWARD_CATEGORY_DTO_NOTIFICATION = 2; + STORE_AND_FORWARD_CATEGORY_DTO_CACHED_DB_WRITE = 3; +} + +enum AlarmStateDto { + ALARM_STATE_DTO_UNSPECIFIED = 0; + ALARM_STATE_DTO_ACTIVE = 1; + ALARM_STATE_DTO_NORMAL = 2; +} + +enum AlarmLevelDto { + ALARM_LEVEL_DTO_UNSPECIFIED = 0; + ALARM_LEVEL_DTO_NONE = 1; + ALARM_LEVEL_DTO_LOW = 2; + ALARM_LEVEL_DTO_LOW_LOW = 3; + ALARM_LEVEL_DTO_HIGH = 4; + ALARM_LEVEL_DTO_HIGH_HIGH = 5; +} + +enum AlarmKindDto { + ALARM_KIND_DTO_UNSPECIFIED = 0; + ALARM_KIND_DTO_COMPUTED = 1; + ALARM_KIND_DTO_NATIVE_OPC_UA = 2; + ALARM_KIND_DTO_NATIVE_MX_ACCESS = 3; +} + +enum AlarmShelveStateDto { + ALARM_SHELVE_STATE_DTO_UNSPECIFIED = 0; + ALARM_SHELVE_STATE_DTO_UNSHELVED = 1; + ALARM_SHELVE_STATE_DTO_ONE_SHOT_SHELVED = 2; + ALARM_SHELVE_STATE_DTO_TIMED_SHELVED = 3; + ALARM_SHELVE_STATE_DTO_PERMANENT_SHELVED = 4; +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 1 — ExecuteLifecycle +// ───────────────────────────────────────────────────────────────────────────── + +message RefreshDeploymentCommandDto { + string deployment_id = 1; + string instance_unique_name = 2; + string revision_hash = 3; + string deployed_by = 4; + google.protobuf.Timestamp timestamp = 5; + string central_fetch_base_url = 6; + string fetch_token = 7; +} + +message EnableInstanceCommandDto { + string command_id = 1; + string instance_unique_name = 2; + google.protobuf.Timestamp timestamp = 3; +} + +message DisableInstanceCommandDto { + string command_id = 1; + string instance_unique_name = 2; + google.protobuf.Timestamp timestamp = 3; +} + +message DeleteInstanceCommandDto { + string command_id = 1; + string instance_unique_name = 2; + google.protobuf.Timestamp timestamp = 3; +} + +message DeploymentStateQueryRequestDto { + string correlation_id = 1; + string instance_unique_name = 2; + google.protobuf.Timestamp timestamp = 3; +} + +message SharedScriptArtifactDto { + string name = 1; + string code = 2; + string parameter_definitions = 3; // empty string represents null + string return_definition = 4; // empty string represents null +} + +message ExternalSystemArtifactDto { + string name = 1; + string endpoint_url = 2; + string auth_type = 3; + string auth_configuration = 4; // empty string represents null + string method_definitions_json = 5; // empty string represents null + int32 timeout_seconds = 6; +} + +message DatabaseConnectionArtifactDto { + string name = 1; + string connection_string = 2; + int32 max_retries = 3; + google.protobuf.Duration retry_delay = 4; +} + +message NotificationListArtifactDto { + string name = 1; + repeated string recipient_emails = 2; +} + +message DataConnectionArtifactDto { + string name = 1; + string protocol = 2; + string primary_configuration_json = 3; // empty string represents null + string backup_configuration_json = 4; // empty string represents null + int32 failover_retry_count = 5; +} + +message SmtpConfigurationArtifactDto { + string name = 1; + string server = 2; + int32 port = 3; + string auth_mode = 4; + string from_address = 5; + string username = 6; // empty string represents null + string password = 7; // empty string represents null + string oauth_config = 8; // empty string represents null +} + +// Each artifact collection on DeployArtifactsCommand is a NULLABLE list, and +// proto3 `repeated` cannot distinguish null from empty. Wrapping each in its +// own message makes the null/empty distinction a message-presence question, +// which proto3 does model — the same silent-data-loss class the transport +// round-trip guard caught in PLAN-05 T8. +message SharedScriptArtifactListDto { repeated SharedScriptArtifactDto items = 1; } +message ExternalSystemArtifactListDto { repeated ExternalSystemArtifactDto items = 1; } +message DatabaseConnectionArtifactListDto { repeated DatabaseConnectionArtifactDto items = 1; } +message NotificationListArtifactListDto { repeated NotificationListArtifactDto items = 1; } +message DataConnectionArtifactListDto { repeated DataConnectionArtifactDto items = 1; } +message SmtpConfigurationArtifactListDto { repeated SmtpConfigurationArtifactDto items = 1; } + +message DeployArtifactsCommandDto { + string deployment_id = 1; + SharedScriptArtifactListDto shared_scripts = 2; // absent => null + ExternalSystemArtifactListDto external_systems = 3; // absent => null + DatabaseConnectionArtifactListDto database_connections = 4; // absent => null + NotificationListArtifactListDto notification_lists = 5; // absent => null + DataConnectionArtifactListDto data_connections = 6; // absent => null + SmtpConfigurationArtifactListDto smtp_configurations = 7; // absent => null + google.protobuf.Timestamp timestamp = 8; +} + +message DeploymentStatusResponseDto { + string deployment_id = 1; + string instance_unique_name = 2; + DeploymentStatusDto status = 3; + string error_message = 4; // empty string represents null + google.protobuf.Timestamp timestamp = 5; +} + +message InstanceLifecycleResponseDto { + string command_id = 1; + string instance_unique_name = 2; + bool success = 3; + string error_message = 4; // empty string represents null + google.protobuf.Timestamp timestamp = 5; +} + +message DeploymentStateQueryResponseDto { + string correlation_id = 1; + string instance_unique_name = 2; + bool is_deployed = 3; + string applied_deployment_id = 4; // empty string represents null + string applied_revision_hash = 5; // empty string represents null + google.protobuf.Timestamp timestamp = 6; +} + +message ArtifactDeploymentResponseDto { + string deployment_id = 1; + string site_id = 2; + bool success = 3; + string error_message = 4; // empty string represents null + google.protobuf.Timestamp timestamp = 5; +} + +message LifecycleRequest { + oneof command { + RefreshDeploymentCommandDto refresh_deployment = 1; + EnableInstanceCommandDto enable_instance = 2; + DisableInstanceCommandDto disable_instance = 3; + DeleteInstanceCommandDto delete_instance = 4; + DeploymentStateQueryRequestDto deployment_state_query = 5; + DeployArtifactsCommandDto deploy_artifacts = 6; + } +} + +message LifecycleReply { + oneof reply { + DeploymentStatusResponseDto deployment_status = 1; + InstanceLifecycleResponseDto instance_lifecycle = 2; + DeploymentStateQueryResponseDto deployment_state_query = 3; + ArtifactDeploymentResponseDto artifact_deployment = 4; + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 2 — ExecuteOpcUa +// ───────────────────────────────────────────────────────────────────────────── + +message BrowseNodeCommandDto { + string connection_name = 1; + string parent_node_id = 2; // empty string represents null (browse root) + string continuation_token = 3; // empty string represents null (first page) + string site_identifier = 4; // empty string represents null +} + +message BrowseNodeDto { + string node_id = 1; + string display_name = 2; + BrowseNodeClassDto node_class = 3; + bool has_children = 4; + string data_type = 5; // empty string represents null + google.protobuf.Int32Value value_rank = 6; // absent => null + google.protobuf.BoolValue writable = 7; // absent => null +} + +message BrowseFailureDto { + BrowseFailureKindDto kind = 1; + string message = 2; +} + +message BrowseNodeResultDto { + repeated BrowseNodeDto children = 1; + bool truncated = 2; + BrowseFailureDto failure = 3; // absent => null (success) + string continuation_token = 4; // empty string represents null (final page) +} + +message SearchAddressSpaceCommandDto { + string connection_name = 1; + string query = 2; + int32 max_depth = 3; + int32 max_results = 4; + string site_identifier = 5; // empty string represents null +} + +message AddressSpaceMatchDto { + BrowseNodeDto node = 1; + string path = 2; +} + +message SearchAddressSpaceResultDto { + repeated AddressSpaceMatchDto matches = 1; + bool cap_reached = 2; + BrowseFailureDto failure = 3; // absent => null (success) +} + +message ReadTagValuesCommandDto { + string connection_name = 1; + repeated string tag_paths = 2; +} + +message TagReadOutcomeDto { + string tag_path = 1; + bool success = 2; + LooseValue value = 3; // absent => null + string quality = 4; + google.protobuf.Timestamp timestamp = 5; + string error_message = 6; // empty string represents null +} + +message ReadTagValuesFailureDto { + ReadTagValuesFailureKindDto kind = 1; + string message = 2; +} + +message ReadTagValuesResultDto { + repeated TagReadOutcomeDto outcomes = 1; + ReadTagValuesFailureDto failure = 2; // absent => null (success) +} + +message VerifyEndpointCommandDto { + string connection_name = 1; + string protocol = 2; + string config_json = 3; + string site_identifier = 4; // empty string represents null +} + +message ServerCertInfoDto { + string thumbprint = 1; + string subject = 2; + string issuer = 3; + google.protobuf.Timestamp not_before_utc = 4; + google.protobuf.Timestamp not_after_utc = 5; + string der_base64 = 6; +} + +// failure_kind is a NULLABLE enum on the CLR side, and proto3 enums have no +// presence, so it rides inside a one-field message exactly like Int32Value. +message VerifyFailureKindValue { VerifyFailureKindDto value = 1; } + +message VerifyEndpointResultDto { + bool success = 1; + VerifyFailureKindValue failure_kind = 2; // absent => null (success) + string error = 3; // empty string represents null + ServerCertInfoDto cert = 4; // absent => null +} + +message TrustServerCertCommandDto { + string connection_name = 1; + string der_base64 = 2; + string thumbprint = 3; + string site_identifier = 4; // empty string represents null +} + +message ListServerCertsCommandDto { + string site_identifier = 1; // empty string represents null +} + +message RemoveServerCertCommandDto { + string thumbprint = 1; + string site_identifier = 2; // empty string represents null +} + +message TrustedCertInfoDto { + string thumbprint = 1; + string subject = 2; + string issuer = 3; + google.protobuf.Timestamp not_before_utc = 4; + google.protobuf.Timestamp not_after_utc = 5; + bool rejected = 6; +} + +// CertTrustResult.Certs is a nullable list (null for trust/remove, populated +// for list) — same null-vs-empty problem as the artifact collections. +message TrustedCertInfoListDto { repeated TrustedCertInfoDto items = 1; } + +message CertTrustResultDto { + bool success = 1; + string error = 2; // empty string represents null + TrustedCertInfoListDto certs = 3; // absent => null +} + +message WriteTagRequestDto { + string correlation_id = 1; + string connection_name = 2; + string tag_path = 3; + LooseValue value = 4; // absent => null + google.protobuf.Timestamp timestamp = 5; +} + +message WriteTagResponseDto { + string correlation_id = 1; + bool success = 2; + string error_message = 3; // empty string represents null + google.protobuf.Timestamp timestamp = 4; +} + +message OpcUaRequest { + oneof command { + BrowseNodeCommandDto browse_node = 1; + SearchAddressSpaceCommandDto search_address_space = 2; + ReadTagValuesCommandDto read_tag_values = 3; + VerifyEndpointCommandDto verify_endpoint = 4; + TrustServerCertCommandDto trust_server_cert = 5; + ListServerCertsCommandDto list_server_certs = 6; + RemoveServerCertCommandDto remove_server_cert = 7; + WriteTagRequestDto write_tag = 8; + } +} + +message OpcUaReply { + oneof reply { + BrowseNodeResultDto browse_node = 1; + SearchAddressSpaceResultDto search_address_space = 2; + ReadTagValuesResultDto read_tag_values = 3; + VerifyEndpointResultDto verify_endpoint = 4; + CertTrustResultDto cert_trust = 5; + WriteTagResponseDto write_tag = 6; + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 3 — ExecuteQuery +// ───────────────────────────────────────────────────────────────────────────── + +message EventLogQueryRequestDto { + string correlation_id = 1; + string site_id = 2; + google.protobuf.Timestamp from = 3; // absent => null + google.protobuf.Timestamp to = 4; // absent => null + string event_type = 5; // empty string represents null + string severity = 6; // empty string represents null + string instance_id = 7; // empty string represents null + string keyword_filter = 8; // empty string represents null + string continuation_token = 9; // empty string represents null + int32 page_size = 10; + google.protobuf.Timestamp timestamp = 11; +} + +message EventLogEntryDto { + string id = 1; + google.protobuf.Timestamp timestamp = 2; + string event_type = 3; + string severity = 4; + string instance_id = 5; // empty string represents null + string source = 6; + string message = 7; + string details = 8; // empty string represents null +} + +message EventLogQueryResponseDto { + string correlation_id = 1; + string site_id = 2; + repeated EventLogEntryDto entries = 3; + string continuation_token = 4; // empty string represents null + bool has_more = 5; + bool success = 6; + string error_message = 7; // empty string represents null + google.protobuf.Timestamp timestamp = 8; +} + +message DebugSnapshotRequestDto { + string instance_unique_name = 1; + string correlation_id = 2; +} + +message SubscribeDebugViewRequestDto { + string instance_unique_name = 1; + string correlation_id = 2; +} + +message UnsubscribeDebugViewRequestDto { + string instance_unique_name = 1; + string correlation_id = 2; +} + +// UnsubscribeDebugView is a Tell today (CommunicationService.UnsubscribeDebugView +// fires and forgets). A unary RPC must still answer something, so the site sends +// this empty ack; the central transport ignores it to keep the caller-visible +// fire-and-forget semantics identical. +message UnsubscribeDebugViewAckDto {} + +message AlarmConditionStateDto { + bool active = 1; + bool acknowledged = 2; + google.protobuf.BoolValue confirmed = 3; // absent => null (not confirmable) + AlarmShelveStateDto shelve = 4; + bool suppressed = 5; + int32 severity = 6; +} + +message DebugAttributeValueDto { + string instance_unique_name = 1; + string attribute_path = 2; + string attribute_name = 3; + LooseValue value = 4; // absent => null + string quality = 5; + google.protobuf.Timestamp timestamp = 6; +} + +// Full-fidelity projection of Commons AlarmStateChanged. Deliberately NOT the +// sitestream AlarmStateUpdate: that one flattens the value to a display string +// and the shelve state to free text, which is right for a live stream but would +// lose data on a snapshot the central UI renders as authoritative state. +message DebugAlarmStateDto { + string instance_unique_name = 1; + string alarm_name = 2; + AlarmStateDto state = 3; + int32 priority = 4; + google.protobuf.Timestamp timestamp = 5; + AlarmLevelDto level = 6; + string message = 7; + AlarmKindDto kind = 8; + // Absent means "not explicitly set" — the CLR record then derives the + // computed default from state + priority. See the mapper's note on why the + // encoder omits a condition that already equals that derived default. + AlarmConditionStateDto condition = 9; + string source_reference = 10; + string alarm_type_name = 11; + string category = 12; + string operator_user = 13; + string operator_comment = 14; + google.protobuf.Timestamp original_raise_time = 15; // absent => null + string current_value = 16; + string limit_value = 17; + string native_source_canonical_name = 18; + bool is_configured_placeholder = 19; +} + +message DebugViewSnapshotDto { + string instance_unique_name = 1; + repeated DebugAttributeValueDto attribute_values = 2; + repeated DebugAlarmStateDto alarm_states = 3; + google.protobuf.Timestamp snapshot_timestamp = 4; + bool instance_not_found = 5; +} + +message QueryRequest { + oneof command { + EventLogQueryRequestDto event_log_query = 1; + DebugSnapshotRequestDto debug_snapshot = 2; + SubscribeDebugViewRequestDto subscribe_debug_view = 3; + UnsubscribeDebugViewRequestDto unsubscribe_debug_view = 4; + } +} + +message QueryReply { + oneof reply { + EventLogQueryResponseDto event_log_query = 1; + DebugViewSnapshotDto debug_view_snapshot = 2; + UnsubscribeDebugViewAckDto unsubscribe_debug_view = 3; + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 4 — ExecuteParked +// ───────────────────────────────────────────────────────────────────────────── + +message ParkedMessageQueryRequestDto { + string correlation_id = 1; + string site_id = 2; + int32 page_number = 3; + int32 page_size = 4; + google.protobuf.Timestamp timestamp = 5; +} + +message ParkedMessageEntryDto { + string message_id = 1; + string target_system = 2; + string method_name = 3; + string error_message = 4; + int32 attempt_count = 5; + google.protobuf.Timestamp original_timestamp = 6; + google.protobuf.Timestamp last_attempt_timestamp = 7; + int32 max_attempts = 8; + StoreAndForwardCategoryDto category = 9; + string origin_instance = 10; // empty string represents null +} + +message ParkedMessageQueryResponseDto { + string correlation_id = 1; + string site_id = 2; + repeated ParkedMessageEntryDto messages = 3; + int32 total_count = 4; + int32 page_number = 5; + int32 page_size = 6; + bool success = 7; + string error_message = 8; // empty string represents null + google.protobuf.Timestamp timestamp = 9; +} + +message ParkedMessageRetryRequestDto { + string correlation_id = 1; + string site_id = 2; + string message_id = 3; + google.protobuf.Timestamp timestamp = 4; +} + +message ParkedMessageRetryResponseDto { + string correlation_id = 1; + bool success = 2; + string error_message = 3; // empty string represents null +} + +message ParkedMessageDiscardRequestDto { + string correlation_id = 1; + string site_id = 2; + string message_id = 3; + google.protobuf.Timestamp timestamp = 4; +} + +message ParkedMessageDiscardResponseDto { + string correlation_id = 1; + bool success = 2; + string error_message = 3; // empty string represents null +} + +message RetryParkedOperationDto { + string correlation_id = 1; + string tracked_operation_id = 2; // TrackedOperationId GUID, "D" format +} + +message DiscardParkedOperationDto { + string correlation_id = 1; + string tracked_operation_id = 2; // TrackedOperationId GUID, "D" format +} + +message ParkedOperationActionAckDto { + string correlation_id = 1; + bool applied = 2; + string error_message = 3; // empty string represents null +} + +message ParkedRequest { + oneof command { + ParkedMessageQueryRequestDto parked_message_query = 1; + ParkedMessageRetryRequestDto parked_message_retry = 2; + ParkedMessageDiscardRequestDto parked_message_discard = 3; + RetryParkedOperationDto retry_parked_operation = 4; + DiscardParkedOperationDto discard_parked_operation = 5; + } +} + +message ParkedReply { + oneof reply { + ParkedMessageQueryResponseDto parked_message_query = 1; + ParkedMessageRetryResponseDto parked_message_retry = 2; + ParkedMessageDiscardResponseDto parked_message_discard = 3; + ParkedOperationActionAckDto parked_operation_action = 4; + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 5 — ExecuteRoute +// ───────────────────────────────────────────────────────────────────────────── + +message RouteToCallRequestDto { + string correlation_id = 1; + string instance_unique_name = 2; + string script_name = 3; + LooseValueMap parameters = 4; // absent => null (distinct from empty) + google.protobuf.Timestamp timestamp = 5; + string parent_execution_id = 6; // empty string represents null +} + +message RouteToCallResponseDto { + string correlation_id = 1; + bool success = 2; + LooseValue return_value = 3; // absent => null + string error_message = 4; // empty string represents null + google.protobuf.Timestamp timestamp = 5; +} + +message RouteToGetAttributesRequestDto { + string correlation_id = 1; + string instance_unique_name = 2; + repeated string attribute_names = 3; + google.protobuf.Timestamp timestamp = 4; + string parent_execution_id = 5; // empty string represents null +} + +message RouteToGetAttributesResponseDto { + string correlation_id = 1; + LooseValueMap values = 2; // non-nullable on the CLR side; absent => empty + bool success = 3; + string error_message = 4; // empty string represents null + google.protobuf.Timestamp timestamp = 5; +} + +message RouteToSetAttributesRequestDto { + string correlation_id = 1; + string instance_unique_name = 2; + map attribute_values = 3; + google.protobuf.Timestamp timestamp = 4; + string parent_execution_id = 5; // empty string represents null +} + +message RouteToSetAttributesResponseDto { + string correlation_id = 1; + bool success = 2; + string error_message = 3; // empty string represents null + google.protobuf.Timestamp timestamp = 4; +} + +message RouteToWaitForAttributeRequestDto { + string correlation_id = 1; + string instance_unique_name = 2; + string attribute_name = 3; + // NOT the empty-string-means-null convention: "wait for this attribute to + // become the empty string" is a legitimate target that must stay distinct + // from "no target supplied", so this one nullable string rides a wrapper. + google.protobuf.StringValue target_value_encoded = 4; + google.protobuf.Duration timeout = 5; + google.protobuf.Timestamp timestamp = 6; + string parent_execution_id = 7; // empty string represents null + bool require_good_quality = 8; +} + +message RouteToWaitForAttributeResponseDto { + string correlation_id = 1; + bool matched = 2; + LooseValue value = 3; // absent => null + string quality = 4; // empty string represents null + bool timed_out = 5; + bool success = 6; + string error_message = 7; // empty string represents null + google.protobuf.Timestamp timestamp = 8; +} + +message RouteRequest { + oneof command { + RouteToCallRequestDto route_to_call = 1; + RouteToGetAttributesRequestDto route_to_get_attributes = 2; + RouteToSetAttributesRequestDto route_to_set_attributes = 3; + RouteToWaitForAttributeRequestDto route_to_wait_for_attribute = 4; + } +} + +message RouteReply { + oneof reply { + RouteToCallResponseDto route_to_call = 1; + RouteToGetAttributesResponseDto route_to_get_attributes = 2; + RouteToSetAttributesResponseDto route_to_set_attributes = 3; + RouteToWaitForAttributeResponseDto route_to_wait_for_attribute = 4; + } +} + +// ───────────────────────────────────────────────────────────────────────────── +// RPC 6 — TriggerFailover +// ───────────────────────────────────────────────────────────────────────────── + +message TriggerSiteFailoverDto { + string correlation_id = 1; + string site_id = 2; +} + +message SiteFailoverAckDto { + string correlation_id = 1; + bool accepted = 2; + string target_address = 3; // empty string represents null + string error_message = 4; // empty string represents null +} diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommand.cs b/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommand.cs new file mode 100644 index 00000000..d8e45300 --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommand.cs @@ -0,0 +1,31813 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Protos/site_command.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc { + + /// Holder for reflection information generated from Protos/site_command.proto + public static partial class SiteCommandReflection { + + #region Descriptor + /// File descriptor for Protos/site_command.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static SiteCommandReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChlQcm90b3Mvc2l0ZV9jb21tYW5kLnByb3RvEhpzY2FkYWJyaWRnZS5zaXRl", + "Y29tbWFuZC52MRofZ29vZ2xlL3Byb3RvYnVmL3RpbWVzdGFtcC5wcm90bxoe", + "Z29vZ2xlL3Byb3RvYnVmL2R1cmF0aW9uLnByb3RvGh5nb29nbGUvcHJvdG9i", + "dWYvd3JhcHBlcnMucHJvdG8iCwoJTG9vc2VOdWxsIkcKDkxvb3NlVmFsdWVM", + "aXN0EjUKBWl0ZW1zGAEgAygLMiYuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQu", + "djEuTG9vc2VWYWx1ZSKwAQoNTG9vc2VWYWx1ZU1hcBJHCgdlbnRyaWVzGAEg", + "AygLMjYuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTG9vc2VWYWx1ZU1h", + "cC5FbnRyaWVzRW50cnkaVgoMRW50cmllc0VudHJ5EgsKA2tleRgBIAEoCRI1", + "CgV2YWx1ZRgCIAEoCzImLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkxv", + "b3NlVmFsdWU6AjgBIpIECgpMb29zZVZhbHVlEjsKCm51bGxfdmFsdWUYASAB", + "KAsyJS5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5Mb29zZU51bGxIABIU", + "Cgpib29sX3ZhbHVlGAIgASgISAASFQoLaW50MzJfdmFsdWUYAyABKAVIABIV", + "CgtpbnQ2NF92YWx1ZRgEIAEoA0gAEhYKDGRvdWJsZV92YWx1ZRgFIAEoAUgA", + "EhUKC2Zsb2F0X3ZhbHVlGAYgASgCSAASFgoMc3RyaW5nX3ZhbHVlGAcgASgJ", + "SAASFwoNZGVjaW1hbF92YWx1ZRgIIAEoCUgAEhkKD2RhdGVfdGltZV92YWx1", + "ZRgJIAEoCUgAEiAKFmRhdGVfdGltZV9vZmZzZXRfdmFsdWUYCiABKAlIABIU", + "CgpndWlkX3ZhbHVlGAsgASgJSAASGQoPdGltZV9zcGFuX3ZhbHVlGAwgASgJ", + "SAASFQoLYnl0ZXNfdmFsdWUYDSABKAxIABJACgpsaXN0X3ZhbHVlGA4gASgL", + "Miouc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTG9vc2VWYWx1ZUxpc3RI", + "ABI+CgltYXBfdmFsdWUYDyABKAsyKS5zY2FkYWJyaWRnZS5zaXRlY29tbWFu", + "ZC52MS5Mb29zZVZhbHVlTWFwSAASFAoKanNvbl92YWx1ZRgQIAEoCUgAQgYK", + "BGtpbmQi4gEKG1JlZnJlc2hEZXBsb3ltZW50Q29tbWFuZER0bxIVCg1kZXBs", + "b3ltZW50X2lkGAEgASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJ", + "EhUKDXJldmlzaW9uX2hhc2gYAyABKAkSEwoLZGVwbG95ZWRfYnkYBCABKAkS", + "LQoJdGltZXN0YW1wGAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFt", + "cBIeChZjZW50cmFsX2ZldGNoX2Jhc2VfdXJsGAYgASgJEhMKC2ZldGNoX3Rv", + "a2VuGAcgASgJInsKGEVuYWJsZUluc3RhbmNlQ29tbWFuZER0bxISCgpjb21t", + "YW5kX2lkGAEgASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJEi0K", + "CXRpbWVzdGFtcBgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAi", + "fAoZRGlzYWJsZUluc3RhbmNlQ29tbWFuZER0bxISCgpjb21tYW5kX2lkGAEg", + "ASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJEi0KCXRpbWVzdGFt", + "cBgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiewoYRGVsZXRl", + "SW5zdGFuY2VDb21tYW5kRHRvEhIKCmNvbW1hbmRfaWQYASABKAkSHAoUaW5z", + "dGFuY2VfdW5pcXVlX25hbWUYAiABKAkSLQoJdGltZXN0YW1wGAMgASgLMhou", + "Z29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCKFAQoeRGVwbG95bWVudFN0YXRl", + "UXVlcnlSZXF1ZXN0RHRvEhYKDmNvcnJlbGF0aW9uX2lkGAEgASgJEhwKFGlu", + "c3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJEi0KCXRpbWVzdGFtcBgDIAEoCzIa", + "Lmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAibwoXU2hhcmVkU2NyaXB0QXJ0", + "aWZhY3REdG8SDAoEbmFtZRgBIAEoCRIMCgRjb2RlGAIgASgJEh0KFXBhcmFt", + "ZXRlcl9kZWZpbml0aW9ucxgDIAEoCRIZChFyZXR1cm5fZGVmaW5pdGlvbhgE", + "IAEoCSKoAQoZRXh0ZXJuYWxTeXN0ZW1BcnRpZmFjdER0bxIMCgRuYW1lGAEg", + "ASgJEhQKDGVuZHBvaW50X3VybBgCIAEoCRIRCglhdXRoX3R5cGUYAyABKAkS", + "GgoSYXV0aF9jb25maWd1cmF0aW9uGAQgASgJEh8KF21ldGhvZF9kZWZpbml0", + "aW9uc19qc29uGAUgASgJEhcKD3RpbWVvdXRfc2Vjb25kcxgGIAEoBSKNAQod", + "RGF0YWJhc2VDb25uZWN0aW9uQXJ0aWZhY3REdG8SDAoEbmFtZRgBIAEoCRIZ", + "ChFjb25uZWN0aW9uX3N0cmluZxgCIAEoCRITCgttYXhfcmV0cmllcxgDIAEo", + "BRIuCgtyZXRyeV9kZWxheRgEIAEoCzIZLmdvb2dsZS5wcm90b2J1Zi5EdXJh", + "dGlvbiJFChtOb3RpZmljYXRpb25MaXN0QXJ0aWZhY3REdG8SDAoEbmFtZRgB", + "IAEoCRIYChByZWNpcGllbnRfZW1haWxzGAIgAygJIqABChlEYXRhQ29ubmVj", + "dGlvbkFydGlmYWN0RHRvEgwKBG5hbWUYASABKAkSEAoIcHJvdG9jb2wYAiAB", + "KAkSIgoacHJpbWFyeV9jb25maWd1cmF0aW9uX2pzb24YAyABKAkSIQoZYmFj", + "a3VwX2NvbmZpZ3VyYXRpb25fanNvbhgEIAEoCRIcChRmYWlsb3Zlcl9yZXRy", + "eV9jb3VudBgFIAEoBSKtAQocU210cENvbmZpZ3VyYXRpb25BcnRpZmFjdER0", + "bxIMCgRuYW1lGAEgASgJEg4KBnNlcnZlchgCIAEoCRIMCgRwb3J0GAMgASgF", + "EhEKCWF1dGhfbW9kZRgEIAEoCRIUCgxmcm9tX2FkZHJlc3MYBSABKAkSEAoI", + "dXNlcm5hbWUYBiABKAkSEAoIcGFzc3dvcmQYByABKAkSFAoMb2F1dGhfY29u", + "ZmlnGAggASgJImEKG1NoYXJlZFNjcmlwdEFydGlmYWN0TGlzdER0bxJCCgVp", + "dGVtcxgBIAMoCzIzLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlNoYXJl", + "ZFNjcmlwdEFydGlmYWN0RHRvImUKHUV4dGVybmFsU3lzdGVtQXJ0aWZhY3RM", + "aXN0RHRvEkQKBWl0ZW1zGAEgAygLMjUuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1h", + "bmQudjEuRXh0ZXJuYWxTeXN0ZW1BcnRpZmFjdER0byJtCiFEYXRhYmFzZUNv", + "bm5lY3Rpb25BcnRpZmFjdExpc3REdG8SSAoFaXRlbXMYASADKAsyOS5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5EYXRhYmFzZUNvbm5lY3Rpb25BcnRp", + "ZmFjdER0byJpCh9Ob3RpZmljYXRpb25MaXN0QXJ0aWZhY3RMaXN0RHRvEkYK", + "BWl0ZW1zGAEgAygLMjcuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTm90", + "aWZpY2F0aW9uTGlzdEFydGlmYWN0RHRvImUKHURhdGFDb25uZWN0aW9uQXJ0", + "aWZhY3RMaXN0RHRvEkQKBWl0ZW1zGAEgAygLMjUuc2NhZGFicmlkZ2Uuc2l0", + "ZWNvbW1hbmQudjEuRGF0YUNvbm5lY3Rpb25BcnRpZmFjdER0byJrCiBTbXRw", + "Q29uZmlndXJhdGlvbkFydGlmYWN0TGlzdER0bxJHCgVpdGVtcxgBIAMoCzI4", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlNtdHBDb25maWd1cmF0aW9u", + "QXJ0aWZhY3REdG8i7QQKGURlcGxveUFydGlmYWN0c0NvbW1hbmREdG8SFQoN", + "ZGVwbG95bWVudF9pZBgBIAEoCRJPCg5zaGFyZWRfc2NyaXB0cxgCIAEoCzI3", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlNoYXJlZFNjcmlwdEFydGlm", + "YWN0TGlzdER0bxJTChBleHRlcm5hbF9zeXN0ZW1zGAMgASgLMjkuc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRXh0ZXJuYWxTeXN0ZW1BcnRpZmFjdExp", + "c3REdG8SWwoUZGF0YWJhc2VfY29ubmVjdGlvbnMYBCABKAsyPS5zY2FkYWJy", + "aWRnZS5zaXRlY29tbWFuZC52MS5EYXRhYmFzZUNvbm5lY3Rpb25BcnRpZmFj", + "dExpc3REdG8SVwoSbm90aWZpY2F0aW9uX2xpc3RzGAUgASgLMjsuc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTm90aWZpY2F0aW9uTGlzdEFydGlmYWN0", + "TGlzdER0bxJTChBkYXRhX2Nvbm5lY3Rpb25zGAYgASgLMjkuc2NhZGFicmlk", + "Z2Uuc2l0ZWNvbW1hbmQudjEuRGF0YUNvbm5lY3Rpb25BcnRpZmFjdExpc3RE", + "dG8SWQoTc210cF9jb25maWd1cmF0aW9ucxgHIAEoCzI8LnNjYWRhYnJpZGdl", + "LnNpdGVjb21tYW5kLnYxLlNtdHBDb25maWd1cmF0aW9uQXJ0aWZhY3RMaXN0", + "RHRvEi0KCXRpbWVzdGFtcBgIIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l", + "c3RhbXAi2QEKG0RlcGxveW1lbnRTdGF0dXNSZXNwb25zZUR0bxIVCg1kZXBs", + "b3ltZW50X2lkGAEgASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJ", + "Ej8KBnN0YXR1cxgDIAEoDjIvLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYx", + "LkRlcGxveW1lbnRTdGF0dXNEdG8SFQoNZXJyb3JfbWVzc2FnZRgEIAEoCRIt", + "Cgl0aW1lc3RhbXAYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1w", + "IqcBChxJbnN0YW5jZUxpZmVjeWNsZVJlc3BvbnNlRHRvEhIKCmNvbW1hbmRf", + "aWQYASABKAkSHAoUaW5zdGFuY2VfdW5pcXVlX25hbWUYAiABKAkSDwoHc3Vj", + "Y2VzcxgDIAEoCBIVCg1lcnJvcl9tZXNzYWdlGAQgASgJEi0KCXRpbWVzdGFt", + "cBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAi2QEKH0RlcGxv", + "eW1lbnRTdGF0ZVF1ZXJ5UmVzcG9uc2VEdG8SFgoOY29ycmVsYXRpb25faWQY", + "ASABKAkSHAoUaW5zdGFuY2VfdW5pcXVlX25hbWUYAiABKAkSEwoLaXNfZGVw", + "bG95ZWQYAyABKAgSHQoVYXBwbGllZF9kZXBsb3ltZW50X2lkGAQgASgJEh0K", + "FWFwcGxpZWRfcmV2aXNpb25faGFzaBgFIAEoCRItCgl0aW1lc3RhbXAYBiAB", + "KAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIp4BCh1BcnRpZmFjdERl", + "cGxveW1lbnRSZXNwb25zZUR0bxIVCg1kZXBsb3ltZW50X2lkGAEgASgJEg8K", + "B3NpdGVfaWQYAiABKAkSDwoHc3VjY2VzcxgDIAEoCBIVCg1lcnJvcl9tZXNz", + "YWdlGAQgASgJEi0KCXRpbWVzdGFtcBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1", + "Zi5UaW1lc3RhbXAimgQKEExpZmVjeWNsZVJlcXVlc3QSVQoScmVmcmVzaF9k", + "ZXBsb3ltZW50GAEgASgLMjcuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEu", + "UmVmcmVzaERlcGxveW1lbnRDb21tYW5kRHRvSAASTwoPZW5hYmxlX2luc3Rh", + "bmNlGAIgASgLMjQuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRW5hYmxl", + "SW5zdGFuY2VDb21tYW5kRHRvSAASUQoQZGlzYWJsZV9pbnN0YW5jZRgDIAEo", + "CzI1LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkRpc2FibGVJbnN0YW5j", + "ZUNvbW1hbmREdG9IABJPCg9kZWxldGVfaW5zdGFuY2UYBCABKAsyNC5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5EZWxldGVJbnN0YW5jZUNvbW1hbmRE", + "dG9IABJcChZkZXBsb3ltZW50X3N0YXRlX3F1ZXJ5GAUgASgLMjouc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRGVwbG95bWVudFN0YXRlUXVlcnlSZXF1", + "ZXN0RHRvSAASUQoQZGVwbG95X2FydGlmYWN0cxgGIAEoCzI1LnNjYWRhYnJp", + "ZGdlLnNpdGVjb21tYW5kLnYxLkRlcGxveUFydGlmYWN0c0NvbW1hbmREdG9I", + "AEIJCgdjb21tYW5kIoADCg5MaWZlY3ljbGVSZXBseRJUChFkZXBsb3ltZW50", + "X3N0YXR1cxgBIAEoCzI3LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkRl", + "cGxveW1lbnRTdGF0dXNSZXNwb25zZUR0b0gAElYKEmluc3RhbmNlX2xpZmVj", + "eWNsZRgCIAEoCzI4LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkluc3Rh", + "bmNlTGlmZWN5Y2xlUmVzcG9uc2VEdG9IABJdChZkZXBsb3ltZW50X3N0YXRl", + "X3F1ZXJ5GAMgASgLMjsuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRGVw", + "bG95bWVudFN0YXRlUXVlcnlSZXNwb25zZUR0b0gAElgKE2FydGlmYWN0X2Rl", + "cGxveW1lbnQYBCABKAsyOS5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5B", + "cnRpZmFjdERlcGxveW1lbnRSZXNwb25zZUR0b0gAQgcKBXJlcGx5InwKFEJy", + "b3dzZU5vZGVDb21tYW5kRHRvEhcKD2Nvbm5lY3Rpb25fbmFtZRgBIAEoCRIW", + "Cg5wYXJlbnRfbm9kZV9pZBgCIAEoCRIaChJjb250aW51YXRpb25fdG9rZW4Y", + "AyABKAkSFwoPc2l0ZV9pZGVudGlmaWVyGAQgASgJIoICCg1Ccm93c2VOb2Rl", + "RHRvEg8KB25vZGVfaWQYASABKAkSFAoMZGlzcGxheV9uYW1lGAIgASgJEkIK", + "Cm5vZGVfY2xhc3MYAyABKA4yLi5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52", + "MS5Ccm93c2VOb2RlQ2xhc3NEdG8SFAoMaGFzX2NoaWxkcmVuGAQgASgIEhEK", + "CWRhdGFfdHlwZRgFIAEoCRIvCgp2YWx1ZV9yYW5rGAYgASgLMhsuZ29vZ2xl", + "LnByb3RvYnVmLkludDMyVmFsdWUSLAoId3JpdGFibGUYByABKAsyGi5nb29n", + "bGUucHJvdG9idWYuQm9vbFZhbHVlImMKEEJyb3dzZUZhaWx1cmVEdG8SPgoE", + "a2luZBgBIAEoDjIwLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkJyb3dz", + "ZUZhaWx1cmVLaW5kRHRvEg8KB21lc3NhZ2UYAiABKAkiwAEKE0Jyb3dzZU5v", + "ZGVSZXN1bHREdG8SOwoIY2hpbGRyZW4YASADKAsyKS5zY2FkYWJyaWRnZS5z", + "aXRlY29tbWFuZC52MS5Ccm93c2VOb2RlRHRvEhEKCXRydW5jYXRlZBgCIAEo", + "CBI9CgdmYWlsdXJlGAMgASgLMiwuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQu", + "djEuQnJvd3NlRmFpbHVyZUR0bxIaChJjb250aW51YXRpb25fdG9rZW4YBCAB", + "KAkihwEKHFNlYXJjaEFkZHJlc3NTcGFjZUNvbW1hbmREdG8SFwoPY29ubmVj", + "dGlvbl9uYW1lGAEgASgJEg0KBXF1ZXJ5GAIgASgJEhEKCW1heF9kZXB0aBgD", + "IAEoBRITCgttYXhfcmVzdWx0cxgEIAEoBRIXCg9zaXRlX2lkZW50aWZpZXIY", + "BSABKAkiXQoUQWRkcmVzc1NwYWNlTWF0Y2hEdG8SNwoEbm9kZRgBIAEoCzIp", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkJyb3dzZU5vZGVEdG8SDAoE", + "cGF0aBgCIAEoCSK0AQobU2VhcmNoQWRkcmVzc1NwYWNlUmVzdWx0RHRvEkEK", + "B21hdGNoZXMYASADKAsyMC5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5B", + "ZGRyZXNzU3BhY2VNYXRjaER0bxITCgtjYXBfcmVhY2hlZBgCIAEoCBI9Cgdm", + "YWlsdXJlGAMgASgLMiwuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuQnJv", + "d3NlRmFpbHVyZUR0byJFChdSZWFkVGFnVmFsdWVzQ29tbWFuZER0bxIXCg9j", + "b25uZWN0aW9uX25hbWUYASABKAkSEQoJdGFnX3BhdGhzGAIgAygJIsQBChFU", + "YWdSZWFkT3V0Y29tZUR0bxIQCgh0YWdfcGF0aBgBIAEoCRIPCgdzdWNjZXNz", + "GAIgASgIEjUKBXZhbHVlGAMgASgLMiYuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1h", + "bmQudjEuTG9vc2VWYWx1ZRIPCgdxdWFsaXR5GAQgASgJEi0KCXRpbWVzdGFt", + "cBgFIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASFQoNZXJyb3Jf", + "bWVzc2FnZRgGIAEoCSJxChdSZWFkVGFnVmFsdWVzRmFpbHVyZUR0bxJFCgRr", + "aW5kGAEgASgOMjcuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUmVhZFRh", + "Z1ZhbHVlc0ZhaWx1cmVLaW5kRHRvEg8KB21lc3NhZ2UYAiABKAkinwEKFlJl", + "YWRUYWdWYWx1ZXNSZXN1bHREdG8SPwoIb3V0Y29tZXMYASADKAsyLS5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5UYWdSZWFkT3V0Y29tZUR0bxJECgdm", + "YWlsdXJlGAIgASgLMjMuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUmVh", + "ZFRhZ1ZhbHVlc0ZhaWx1cmVEdG8icwoYVmVyaWZ5RW5kcG9pbnRDb21tYW5k", + "RHRvEhcKD2Nvbm5lY3Rpb25fbmFtZRgBIAEoCRIQCghwcm90b2NvbBgCIAEo", + "CRITCgtjb25maWdfanNvbhgDIAEoCRIXCg9zaXRlX2lkZW50aWZpZXIYBCAB", + "KAkiwwEKEVNlcnZlckNlcnRJbmZvRHRvEhIKCnRodW1icHJpbnQYASABKAkS", + "DwoHc3ViamVjdBgCIAEoCRIOCgZpc3N1ZXIYAyABKAkSMgoObm90X2JlZm9y", + "ZV91dGMYBCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjEKDW5v", + "dF9hZnRlcl91dGMYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1w", + "EhIKCmRlcl9iYXNlNjQYBiABKAkiWQoWVmVyaWZ5RmFpbHVyZUtpbmRWYWx1", + "ZRI/CgV2YWx1ZRgBIAEoDjIwLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYx", + "LlZlcmlmeUZhaWx1cmVLaW5kRHRvIsABChdWZXJpZnlFbmRwb2ludFJlc3Vs", + "dER0bxIPCgdzdWNjZXNzGAEgASgIEkgKDGZhaWx1cmVfa2luZBgCIAEoCzIy", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlZlcmlmeUZhaWx1cmVLaW5k", + "VmFsdWUSDQoFZXJyb3IYAyABKAkSOwoEY2VydBgEIAEoCzItLnNjYWRhYnJp", + "ZGdlLnNpdGVjb21tYW5kLnYxLlNlcnZlckNlcnRJbmZvRHRvInUKGVRydXN0", + "U2VydmVyQ2VydENvbW1hbmREdG8SFwoPY29ubmVjdGlvbl9uYW1lGAEgASgJ", + "EhIKCmRlcl9iYXNlNjQYAiABKAkSEgoKdGh1bWJwcmludBgDIAEoCRIXCg9z", + "aXRlX2lkZW50aWZpZXIYBCABKAkiNAoZTGlzdFNlcnZlckNlcnRzQ29tbWFu", + "ZER0bxIXCg9zaXRlX2lkZW50aWZpZXIYASABKAkiSQoaUmVtb3ZlU2VydmVy", + "Q2VydENvbW1hbmREdG8SEgoKdGh1bWJwcmludBgBIAEoCRIXCg9zaXRlX2lk", + "ZW50aWZpZXIYAiABKAkiwgEKElRydXN0ZWRDZXJ0SW5mb0R0bxISCgp0aHVt", + "YnByaW50GAEgASgJEg8KB3N1YmplY3QYAiABKAkSDgoGaXNzdWVyGAMgASgJ", + "EjIKDm5vdF9iZWZvcmVfdXRjGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcBIxCg1ub3RfYWZ0ZXJfdXRjGAUgASgLMhouZ29vZ2xlLnByb3Rv", + "YnVmLlRpbWVzdGFtcBIQCghyZWplY3RlZBgGIAEoCCJXChZUcnVzdGVkQ2Vy", + "dEluZm9MaXN0RHRvEj0KBWl0ZW1zGAEgAygLMi4uc2NhZGFicmlkZ2Uuc2l0", + "ZWNvbW1hbmQudjEuVHJ1c3RlZENlcnRJbmZvRHRvIncKEkNlcnRUcnVzdFJl", + "c3VsdER0bxIPCgdzdWNjZXNzGAEgASgIEg0KBWVycm9yGAIgASgJEkEKBWNl", + "cnRzGAMgASgLMjIuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuVHJ1c3Rl", + "ZENlcnRJbmZvTGlzdER0byK9AQoSV3JpdGVUYWdSZXF1ZXN0RHRvEhYKDmNv", + "cnJlbGF0aW9uX2lkGAEgASgJEhcKD2Nvbm5lY3Rpb25fbmFtZRgCIAEoCRIQ", + "Cgh0YWdfcGF0aBgDIAEoCRI1CgV2YWx1ZRgEIAEoCzImLnNjYWRhYnJpZGdl", + "LnNpdGVjb21tYW5kLnYxLkxvb3NlVmFsdWUSLQoJdGltZXN0YW1wGAUgASgL", + "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCKEAQoTV3JpdGVUYWdSZXNw", + "b25zZUR0bxIWCg5jb3JyZWxhdGlvbl9pZBgBIAEoCRIPCgdzdWNjZXNzGAIg", + "ASgIEhUKDWVycm9yX21lc3NhZ2UYAyABKAkSLQoJdGltZXN0YW1wGAQgASgL", + "MhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCKgBQoMT3BjVWFSZXF1ZXN0", + "EkcKC2Jyb3dzZV9ub2RlGAEgASgLMjAuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1h", + "bmQudjEuQnJvd3NlTm9kZUNvbW1hbmREdG9IABJYChRzZWFyY2hfYWRkcmVz", + "c19zcGFjZRgCIAEoCzI4LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlNl", + "YXJjaEFkZHJlc3NTcGFjZUNvbW1hbmREdG9IABJOCg9yZWFkX3RhZ192YWx1", + "ZXMYAyABKAsyMy5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5SZWFkVGFn", + "VmFsdWVzQ29tbWFuZER0b0gAEk8KD3ZlcmlmeV9lbmRwb2ludBgEIAEoCzI0", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlZlcmlmeUVuZHBvaW50Q29t", + "bWFuZER0b0gAElIKEXRydXN0X3NlcnZlcl9jZXJ0GAUgASgLMjUuc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuVHJ1c3RTZXJ2ZXJDZXJ0Q29tbWFuZER0", + "b0gAElIKEWxpc3Rfc2VydmVyX2NlcnRzGAYgASgLMjUuc2NhZGFicmlkZ2Uu", + "c2l0ZWNvbW1hbmQudjEuTGlzdFNlcnZlckNlcnRzQ29tbWFuZER0b0gAElQK", + "EnJlbW92ZV9zZXJ2ZXJfY2VydBgHIAEoCzI2LnNjYWRhYnJpZGdlLnNpdGVj", + "b21tYW5kLnYxLlJlbW92ZVNlcnZlckNlcnRDb21tYW5kRHRvSAASQwoJd3Jp", + "dGVfdGFnGAggASgLMi4uc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuV3Jp", + "dGVUYWdSZXF1ZXN0RHRvSABCCQoHY29tbWFuZCLhAwoKT3BjVWFSZXBseRJG", + "Cgticm93c2Vfbm9kZRgBIAEoCzIvLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5k", + "LnYxLkJyb3dzZU5vZGVSZXN1bHREdG9IABJXChRzZWFyY2hfYWRkcmVzc19z", + "cGFjZRgCIAEoCzI3LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlNlYXJj", + "aEFkZHJlc3NTcGFjZVJlc3VsdER0b0gAEk0KD3JlYWRfdGFnX3ZhbHVlcxgD", + "IAEoCzIyLnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlJlYWRUYWdWYWx1", + "ZXNSZXN1bHREdG9IABJOCg92ZXJpZnlfZW5kcG9pbnQYBCABKAsyMy5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5WZXJpZnlFbmRwb2ludFJlc3VsdER0", + "b0gAEkQKCmNlcnRfdHJ1c3QYBSABKAsyLi5zY2FkYWJyaWRnZS5zaXRlY29t", + "bWFuZC52MS5DZXJ0VHJ1c3RSZXN1bHREdG9IABJECgl3cml0ZV90YWcYBiAB", + "KAsyLy5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5Xcml0ZVRhZ1Jlc3Bv", + "bnNlRHRvSABCBwoFcmVwbHkixQIKF0V2ZW50TG9nUXVlcnlSZXF1ZXN0RHRv", + "EhYKDmNvcnJlbGF0aW9uX2lkGAEgASgJEg8KB3NpdGVfaWQYAiABKAkSKAoE", + "ZnJvbRgDIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASJgoCdG8Y", + "BCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhIKCmV2ZW50X3R5", + "cGUYBSABKAkSEAoIc2V2ZXJpdHkYBiABKAkSEwoLaW5zdGFuY2VfaWQYByAB", + "KAkSFgoOa2V5d29yZF9maWx0ZXIYCCABKAkSGgoSY29udGludWF0aW9uX3Rv", + "a2VuGAkgASgJEhEKCXBhZ2Vfc2l6ZRgKIAEoBRItCgl0aW1lc3RhbXAYCyAB", + "KAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIroBChBFdmVudExvZ0Vu", + "dHJ5RHRvEgoKAmlkGAEgASgJEi0KCXRpbWVzdGFtcBgCIAEoCzIaLmdvb2ds", + "ZS5wcm90b2J1Zi5UaW1lc3RhbXASEgoKZXZlbnRfdHlwZRgDIAEoCRIQCghz", + "ZXZlcml0eRgEIAEoCRITCgtpbnN0YW5jZV9pZBgFIAEoCRIOCgZzb3VyY2UY", + "BiABKAkSDwoHbWVzc2FnZRgHIAEoCRIPCgdkZXRhaWxzGAggASgJIocCChhF", + "dmVudExvZ1F1ZXJ5UmVzcG9uc2VEdG8SFgoOY29ycmVsYXRpb25faWQYASAB", + "KAkSDwoHc2l0ZV9pZBgCIAEoCRI9CgdlbnRyaWVzGAMgAygLMiwuc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRXZlbnRMb2dFbnRyeUR0bxIaChJjb250", + "aW51YXRpb25fdG9rZW4YBCABKAkSEAoIaGFzX21vcmUYBSABKAgSDwoHc3Vj", + "Y2VzcxgGIAEoCBIVCg1lcnJvcl9tZXNzYWdlGAcgASgJEi0KCXRpbWVzdGFt", + "cBgIIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiTwoXRGVidWdT", + "bmFwc2hvdFJlcXVlc3REdG8SHAoUaW5zdGFuY2VfdW5pcXVlX25hbWUYASAB", + "KAkSFgoOY29ycmVsYXRpb25faWQYAiABKAkiVAocU3Vic2NyaWJlRGVidWdW", + "aWV3UmVxdWVzdER0bxIcChRpbnN0YW5jZV91bmlxdWVfbmFtZRgBIAEoCRIW", + "Cg5jb3JyZWxhdGlvbl9pZBgCIAEoCSJWCh5VbnN1YnNjcmliZURlYnVnVmll", + "d1JlcXVlc3REdG8SHAoUaW5zdGFuY2VfdW5pcXVlX25hbWUYASABKAkSFgoO", + "Y29ycmVsYXRpb25faWQYAiABKAkiHAoaVW5zdWJzY3JpYmVEZWJ1Z1ZpZXdB", + "Y2tEdG8i1AEKFkFsYXJtQ29uZGl0aW9uU3RhdGVEdG8SDgoGYWN0aXZlGAEg", + "ASgIEhQKDGFja25vd2xlZGdlZBgCIAEoCBItCgljb25maXJtZWQYAyABKAsy", + "Gi5nb29nbGUucHJvdG9idWYuQm9vbFZhbHVlEj8KBnNoZWx2ZRgEIAEoDjIv", + "LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLkFsYXJtU2hlbHZlU3RhdGVE", + "dG8SEgoKc3VwcHJlc3NlZBgFIAEoCBIQCghzZXZlcml0eRgGIAEoBSLdAQoW", + "RGVidWdBdHRyaWJ1dGVWYWx1ZUR0bxIcChRpbnN0YW5jZV91bmlxdWVfbmFt", + "ZRgBIAEoCRIWCg5hdHRyaWJ1dGVfcGF0aBgCIAEoCRIWCg5hdHRyaWJ1dGVf", + "bmFtZRgDIAEoCRI1CgV2YWx1ZRgEIAEoCzImLnNjYWRhYnJpZGdlLnNpdGVj", + "b21tYW5kLnYxLkxvb3NlVmFsdWUSDwoHcXVhbGl0eRgFIAEoCRItCgl0aW1l", + "c3RhbXAYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wIq8FChJE", + "ZWJ1Z0FsYXJtU3RhdGVEdG8SHAoUaW5zdGFuY2VfdW5pcXVlX25hbWUYASAB", + "KAkSEgoKYWxhcm1fbmFtZRgCIAEoCRI4CgVzdGF0ZRgDIAEoDjIpLnNjYWRh", + "YnJpZGdlLnNpdGVjb21tYW5kLnYxLkFsYXJtU3RhdGVEdG8SEAoIcHJpb3Jp", + "dHkYBCABKAUSLQoJdGltZXN0YW1wGAUgASgLMhouZ29vZ2xlLnByb3RvYnVm", + "LlRpbWVzdGFtcBI4CgVsZXZlbBgGIAEoDjIpLnNjYWRhYnJpZGdlLnNpdGVj", + "b21tYW5kLnYxLkFsYXJtTGV2ZWxEdG8SDwoHbWVzc2FnZRgHIAEoCRI2CgRr", + "aW5kGAggASgOMiguc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuQWxhcm1L", + "aW5kRHRvEkUKCWNvbmRpdGlvbhgJIAEoCzIyLnNjYWRhYnJpZGdlLnNpdGVj", + "b21tYW5kLnYxLkFsYXJtQ29uZGl0aW9uU3RhdGVEdG8SGAoQc291cmNlX3Jl", + "ZmVyZW5jZRgKIAEoCRIXCg9hbGFybV90eXBlX25hbWUYCyABKAkSEAoIY2F0", + "ZWdvcnkYDCABKAkSFQoNb3BlcmF0b3JfdXNlchgNIAEoCRIYChBvcGVyYXRv", + "cl9jb21tZW50GA4gASgJEjcKE29yaWdpbmFsX3JhaXNlX3RpbWUYDyABKAsy", + "Gi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhUKDWN1cnJlbnRfdmFsdWUY", + "ECABKAkSEwoLbGltaXRfdmFsdWUYESABKAkSJAocbmF0aXZlX3NvdXJjZV9j", + "YW5vbmljYWxfbmFtZRgSIAEoCRIhChlpc19jb25maWd1cmVkX3BsYWNlaG9s", + "ZGVyGBMgASgIIpwCChREZWJ1Z1ZpZXdTbmFwc2hvdER0bxIcChRpbnN0YW5j", + "ZV91bmlxdWVfbmFtZRgBIAEoCRJMChBhdHRyaWJ1dGVfdmFsdWVzGAIgAygL", + "MjIuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRGVidWdBdHRyaWJ1dGVW", + "YWx1ZUR0bxJECgxhbGFybV9zdGF0ZXMYAyADKAsyLi5zY2FkYWJyaWRnZS5z", + "aXRlY29tbWFuZC52MS5EZWJ1Z0FsYXJtU3RhdGVEdG8SNgoSc25hcHNob3Rf", + "dGltZXN0YW1wGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcBIa", + "ChJpbnN0YW5jZV9ub3RfZm91bmQYBSABKAgi8AIKDFF1ZXJ5UmVxdWVzdBJO", + "Cg9ldmVudF9sb2dfcXVlcnkYASABKAsyMy5zY2FkYWJyaWRnZS5zaXRlY29t", + "bWFuZC52MS5FdmVudExvZ1F1ZXJ5UmVxdWVzdER0b0gAEk0KDmRlYnVnX3Nu", + "YXBzaG90GAIgASgLMjMuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuRGVi", + "dWdTbmFwc2hvdFJlcXVlc3REdG9IABJYChRzdWJzY3JpYmVfZGVidWdfdmll", + "dxgDIAEoCzI4LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlN1YnNjcmli", + "ZURlYnVnVmlld1JlcXVlc3REdG9IABJcChZ1bnN1YnNjcmliZV9kZWJ1Z192", + "aWV3GAQgASgLMjouc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuVW5zdWJz", + "Y3JpYmVEZWJ1Z1ZpZXdSZXF1ZXN0RHRvSABCCQoHY29tbWFuZCKRAgoKUXVl", + "cnlSZXBseRJPCg9ldmVudF9sb2dfcXVlcnkYASABKAsyNC5zY2FkYWJyaWRn", + "ZS5zaXRlY29tbWFuZC52MS5FdmVudExvZ1F1ZXJ5UmVzcG9uc2VEdG9IABJP", + "ChNkZWJ1Z192aWV3X3NuYXBzaG90GAIgASgLMjAuc2NhZGFicmlkZ2Uuc2l0", + "ZWNvbW1hbmQudjEuRGVidWdWaWV3U25hcHNob3REdG9IABJYChZ1bnN1YnNj", + "cmliZV9kZWJ1Z192aWV3GAMgASgLMjYuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1h", + "bmQudjEuVW5zdWJzY3JpYmVEZWJ1Z1ZpZXdBY2tEdG9IAEIHCgVyZXBseSKe", + "AQocUGFya2VkTWVzc2FnZVF1ZXJ5UmVxdWVzdER0bxIWCg5jb3JyZWxhdGlv", + "bl9pZBgBIAEoCRIPCgdzaXRlX2lkGAIgASgJEhMKC3BhZ2VfbnVtYmVyGAMg", + "ASgFEhEKCXBhZ2Vfc2l6ZRgEIAEoBRItCgl0aW1lc3RhbXAYBSABKAsyGi5n", + "b29nbGUucHJvdG9idWYuVGltZXN0YW1wIvICChVQYXJrZWRNZXNzYWdlRW50", + "cnlEdG8SEgoKbWVzc2FnZV9pZBgBIAEoCRIVCg10YXJnZXRfc3lzdGVtGAIg", + "ASgJEhMKC21ldGhvZF9uYW1lGAMgASgJEhUKDWVycm9yX21lc3NhZ2UYBCAB", + "KAkSFQoNYXR0ZW1wdF9jb3VudBgFIAEoBRI2ChJvcmlnaW5hbF90aW1lc3Rh", + "bXAYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEjoKFmxhc3Rf", + "YXR0ZW1wdF90aW1lc3RhbXAYByABKAsyGi5nb29nbGUucHJvdG9idWYuVGlt", + "ZXN0YW1wEhQKDG1heF9hdHRlbXB0cxgIIAEoBRJICghjYXRlZ29yeRgJIAEo", + "DjI2LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlN0b3JlQW5kRm9yd2Fy", + "ZENhdGVnb3J5RHRvEhcKD29yaWdpbl9pbnN0YW5jZRgKIAEoCSKhAgodUGFy", + "a2VkTWVzc2FnZVF1ZXJ5UmVzcG9uc2VEdG8SFgoOY29ycmVsYXRpb25faWQY", + "ASABKAkSDwoHc2l0ZV9pZBgCIAEoCRJDCghtZXNzYWdlcxgDIAMoCzIxLnNj", + "YWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlBhcmtlZE1lc3NhZ2VFbnRyeUR0", + "bxITCgt0b3RhbF9jb3VudBgEIAEoBRITCgtwYWdlX251bWJlchgFIAEoBRIR", + "CglwYWdlX3NpemUYBiABKAUSDwoHc3VjY2VzcxgHIAEoCBIVCg1lcnJvcl9t", + "ZXNzYWdlGAggASgJEi0KCXRpbWVzdGFtcBgJIAEoCzIaLmdvb2dsZS5wcm90", + "b2J1Zi5UaW1lc3RhbXAiigEKHFBhcmtlZE1lc3NhZ2VSZXRyeVJlcXVlc3RE", + "dG8SFgoOY29ycmVsYXRpb25faWQYASABKAkSDwoHc2l0ZV9pZBgCIAEoCRIS", + "CgptZXNzYWdlX2lkGAMgASgJEi0KCXRpbWVzdGFtcBgEIAEoCzIaLmdvb2ds", + "ZS5wcm90b2J1Zi5UaW1lc3RhbXAiXwodUGFya2VkTWVzc2FnZVJldHJ5UmVz", + "cG9uc2VEdG8SFgoOY29ycmVsYXRpb25faWQYASABKAkSDwoHc3VjY2VzcxgC", + "IAEoCBIVCg1lcnJvcl9tZXNzYWdlGAMgASgJIowBCh5QYXJrZWRNZXNzYWdl", + "RGlzY2FyZFJlcXVlc3REdG8SFgoOY29ycmVsYXRpb25faWQYASABKAkSDwoH", + "c2l0ZV9pZBgCIAEoCRISCgptZXNzYWdlX2lkGAMgASgJEi0KCXRpbWVzdGFt", + "cBgEIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXAiYQofUGFya2Vk", + "TWVzc2FnZURpc2NhcmRSZXNwb25zZUR0bxIWCg5jb3JyZWxhdGlvbl9pZBgB", + "IAEoCRIPCgdzdWNjZXNzGAIgASgIEhUKDWVycm9yX21lc3NhZ2UYAyABKAki", + "TwoXUmV0cnlQYXJrZWRPcGVyYXRpb25EdG8SFgoOY29ycmVsYXRpb25faWQY", + "ASABKAkSHAoUdHJhY2tlZF9vcGVyYXRpb25faWQYAiABKAkiUQoZRGlzY2Fy", + "ZFBhcmtlZE9wZXJhdGlvbkR0bxIWCg5jb3JyZWxhdGlvbl9pZBgBIAEoCRIc", + "ChR0cmFja2VkX29wZXJhdGlvbl9pZBgCIAEoCSJdChtQYXJrZWRPcGVyYXRp", + "b25BY3Rpb25BY2tEdG8SFgoOY29ycmVsYXRpb25faWQYASABKAkSDwoHYXBw", + "bGllZBgCIAEoCBIVCg1lcnJvcl9tZXNzYWdlGAMgASgJIt4DCg1QYXJrZWRS", + "ZXF1ZXN0ElgKFHBhcmtlZF9tZXNzYWdlX3F1ZXJ5GAEgASgLMjguc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUGFya2VkTWVzc2FnZVF1ZXJ5UmVxdWVz", + "dER0b0gAElgKFHBhcmtlZF9tZXNzYWdlX3JldHJ5GAIgASgLMjguc2NhZGFi", + "cmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUGFya2VkTWVzc2FnZVJldHJ5UmVxdWVz", + "dER0b0gAElwKFnBhcmtlZF9tZXNzYWdlX2Rpc2NhcmQYAyABKAsyOi5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5QYXJrZWRNZXNzYWdlRGlzY2FyZFJl", + "cXVlc3REdG9IABJVChZyZXRyeV9wYXJrZWRfb3BlcmF0aW9uGAQgASgLMjMu", + "c2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUmV0cnlQYXJrZWRPcGVyYXRp", + "b25EdG9IABJZChhkaXNjYXJkX3BhcmtlZF9vcGVyYXRpb24YBSABKAsyNS5z", + "Y2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5EaXNjYXJkUGFya2VkT3BlcmF0", + "aW9uRHRvSABCCQoHY29tbWFuZCKHAwoLUGFya2VkUmVwbHkSWQoUcGFya2Vk", + "X21lc3NhZ2VfcXVlcnkYASABKAsyOS5zY2FkYWJyaWRnZS5zaXRlY29tbWFu", + "ZC52MS5QYXJrZWRNZXNzYWdlUXVlcnlSZXNwb25zZUR0b0gAElkKFHBhcmtl", + "ZF9tZXNzYWdlX3JldHJ5GAIgASgLMjkuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1h", + "bmQudjEuUGFya2VkTWVzc2FnZVJldHJ5UmVzcG9uc2VEdG9IABJdChZwYXJr", + "ZWRfbWVzc2FnZV9kaXNjYXJkGAMgASgLMjsuc2NhZGFicmlkZ2Uuc2l0ZWNv", + "bW1hbmQudjEuUGFya2VkTWVzc2FnZURpc2NhcmRSZXNwb25zZUR0b0gAEloK", + "F3BhcmtlZF9vcGVyYXRpb25fYWN0aW9uGAQgASgLMjcuc2NhZGFicmlkZ2Uu", + "c2l0ZWNvbW1hbmQudjEuUGFya2VkT3BlcmF0aW9uQWN0aW9uQWNrRHRvSABC", + "BwoFcmVwbHki7QEKFVJvdXRlVG9DYWxsUmVxdWVzdER0bxIWCg5jb3JyZWxh", + "dGlvbl9pZBgBIAEoCRIcChRpbnN0YW5jZV91bmlxdWVfbmFtZRgCIAEoCRIT", + "CgtzY3JpcHRfbmFtZRgDIAEoCRI9CgpwYXJhbWV0ZXJzGAQgASgLMikuc2Nh", + "ZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTG9vc2VWYWx1ZU1hcBItCgl0aW1l", + "c3RhbXAYBSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEhsKE3Bh", + "cmVudF9leGVjdXRpb25faWQYBiABKAkixQEKFlJvdXRlVG9DYWxsUmVzcG9u", + "c2VEdG8SFgoOY29ycmVsYXRpb25faWQYASABKAkSDwoHc3VjY2VzcxgCIAEo", + "CBI8CgxyZXR1cm5fdmFsdWUYAyABKAsyJi5zY2FkYWJyaWRnZS5zaXRlY29t", + "bWFuZC52MS5Mb29zZVZhbHVlEhUKDWVycm9yX21lc3NhZ2UYBCABKAkSLQoJ", + "dGltZXN0YW1wGAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCK7", + "AQoeUm91dGVUb0dldEF0dHJpYnV0ZXNSZXF1ZXN0RHRvEhYKDmNvcnJlbGF0", + "aW9uX2lkGAEgASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJEhcK", + "D2F0dHJpYnV0ZV9uYW1lcxgDIAMoCRItCgl0aW1lc3RhbXAYBCABKAsyGi5n", + "b29nbGUucHJvdG9idWYuVGltZXN0YW1wEhsKE3BhcmVudF9leGVjdXRpb25f", + "aWQYBSABKAkiywEKH1JvdXRlVG9HZXRBdHRyaWJ1dGVzUmVzcG9uc2VEdG8S", + "FgoOY29ycmVsYXRpb25faWQYASABKAkSOQoGdmFsdWVzGAIgASgLMikuc2Nh", + "ZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuTG9vc2VWYWx1ZU1hcBIPCgdzdWNj", + "ZXNzGAMgASgIEhUKDWVycm9yX21lc3NhZ2UYBCABKAkSLQoJdGltZXN0YW1w", + "GAUgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcCLFAgoeUm91dGVU", + "b1NldEF0dHJpYnV0ZXNSZXF1ZXN0RHRvEhYKDmNvcnJlbGF0aW9uX2lkGAEg", + "ASgJEhwKFGluc3RhbmNlX3VuaXF1ZV9uYW1lGAIgASgJEmkKEGF0dHJpYnV0", + "ZV92YWx1ZXMYAyADKAsyTy5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5S", + "b3V0ZVRvU2V0QXR0cmlidXRlc1JlcXVlc3REdG8uQXR0cmlidXRlVmFsdWVz", + "RW50cnkSLQoJdGltZXN0YW1wGAQgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRp", + "bWVzdGFtcBIbChNwYXJlbnRfZXhlY3V0aW9uX2lkGAUgASgJGjYKFEF0dHJp", + "YnV0ZVZhbHVlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToC", + "OAEikAEKH1JvdXRlVG9TZXRBdHRyaWJ1dGVzUmVzcG9uc2VEdG8SFgoOY29y", + "cmVsYXRpb25faWQYASABKAkSDwoHc3VjY2VzcxgCIAEoCBIVCg1lcnJvcl9t", + "ZXNzYWdlGAMgASgJEi0KCXRpbWVzdGFtcBgEIAEoCzIaLmdvb2dsZS5wcm90", + "b2J1Zi5UaW1lc3RhbXAiwwIKIVJvdXRlVG9XYWl0Rm9yQXR0cmlidXRlUmVx", + "dWVzdER0bxIWCg5jb3JyZWxhdGlvbl9pZBgBIAEoCRIcChRpbnN0YW5jZV91", + "bmlxdWVfbmFtZRgCIAEoCRIWCg5hdHRyaWJ1dGVfbmFtZRgDIAEoCRI6ChR0", + "YXJnZXRfdmFsdWVfZW5jb2RlZBgEIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5T", + "dHJpbmdWYWx1ZRIqCgd0aW1lb3V0GAUgASgLMhkuZ29vZ2xlLnByb3RvYnVm", + "LkR1cmF0aW9uEi0KCXRpbWVzdGFtcBgGIAEoCzIaLmdvb2dsZS5wcm90b2J1", + "Zi5UaW1lc3RhbXASGwoTcGFyZW50X2V4ZWN1dGlvbl9pZBgHIAEoCRIcChRy", + "ZXF1aXJlX2dvb2RfcXVhbGl0eRgIIAEoCCL/AQoiUm91dGVUb1dhaXRGb3JB", + "dHRyaWJ1dGVSZXNwb25zZUR0bxIWCg5jb3JyZWxhdGlvbl9pZBgBIAEoCRIP", + "CgdtYXRjaGVkGAIgASgIEjUKBXZhbHVlGAMgASgLMiYuc2NhZGFicmlkZ2Uu", + "c2l0ZWNvbW1hbmQudjEuTG9vc2VWYWx1ZRIPCgdxdWFsaXR5GAQgASgJEhEK", + "CXRpbWVkX291dBgFIAEoCBIPCgdzdWNjZXNzGAYgASgIEhUKDWVycm9yX21l", + "c3NhZ2UYByABKAkSLQoJdGltZXN0YW1wGAggASgLMhouZ29vZ2xlLnByb3Rv", + "YnVmLlRpbWVzdGFtcCKJAwoMUm91dGVSZXF1ZXN0EkoKDXJvdXRlX3RvX2Nh", + "bGwYASABKAsyMS5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5Sb3V0ZVRv", + "Q2FsbFJlcXVlc3REdG9IABJdChdyb3V0ZV90b19nZXRfYXR0cmlidXRlcxgC", + "IAEoCzI6LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlJvdXRlVG9HZXRB", + "dHRyaWJ1dGVzUmVxdWVzdER0b0gAEl0KF3JvdXRlX3RvX3NldF9hdHRyaWJ1", + "dGVzGAMgASgLMjouc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUm91dGVU", + "b1NldEF0dHJpYnV0ZXNSZXF1ZXN0RHRvSAASZAobcm91dGVfdG9fd2FpdF9m", + "b3JfYXR0cmlidXRlGAQgASgLMj0uc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQu", + "djEuUm91dGVUb1dhaXRGb3JBdHRyaWJ1dGVSZXF1ZXN0RHRvSABCCQoHY29t", + "bWFuZCKJAwoKUm91dGVSZXBseRJLCg1yb3V0ZV90b19jYWxsGAEgASgLMjIu", + "c2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUm91dGVUb0NhbGxSZXNwb25z", + "ZUR0b0gAEl4KF3JvdXRlX3RvX2dldF9hdHRyaWJ1dGVzGAIgASgLMjsuc2Nh", + "ZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUm91dGVUb0dldEF0dHJpYnV0ZXNS", + "ZXNwb25zZUR0b0gAEl4KF3JvdXRlX3RvX3NldF9hdHRyaWJ1dGVzGAMgASgL", + "Mjsuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUm91dGVUb1NldEF0dHJp", + "YnV0ZXNSZXNwb25zZUR0b0gAEmUKG3JvdXRlX3RvX3dhaXRfZm9yX2F0dHJp", + "YnV0ZRgEIAEoCzI+LnNjYWRhYnJpZGdlLnNpdGVjb21tYW5kLnYxLlJvdXRl", + "VG9XYWl0Rm9yQXR0cmlidXRlUmVzcG9uc2VEdG9IAEIHCgVyZXBseSJBChZU", + "cmlnZ2VyU2l0ZUZhaWxvdmVyRHRvEhYKDmNvcnJlbGF0aW9uX2lkGAEgASgJ", + "Eg8KB3NpdGVfaWQYAiABKAkibQoSU2l0ZUZhaWxvdmVyQWNrRHRvEhYKDmNv", + "cnJlbGF0aW9uX2lkGAEgASgJEhAKCGFjY2VwdGVkGAIgASgIEhYKDnRhcmdl", + "dF9hZGRyZXNzGAMgASgJEhUKDWVycm9yX21lc3NhZ2UYBCABKAkqywEKE0Rl", + "cGxveW1lbnRTdGF0dXNEdG8SJQohREVQTE9ZTUVOVF9TVEFUVVNfRFRPX1VO", + "U1BFQ0lGSUVEEAASIQodREVQTE9ZTUVOVF9TVEFUVVNfRFRPX1BFTkRJTkcQ", + "ARIlCiFERVBMT1lNRU5UX1NUQVRVU19EVE9fSU5fUFJPR1JFU1MQAhIhCh1E", + "RVBMT1lNRU5UX1NUQVRVU19EVE9fU1VDQ0VTUxADEiAKHERFUExPWU1FTlRf", + "U1RBVFVTX0RUT19GQUlMRUQQBCrEAQoSQnJvd3NlTm9kZUNsYXNzRHRvEiUK", + "IUJST1dTRV9OT0RFX0NMQVNTX0RUT19VTlNQRUNJRklFRBAAEiAKHEJST1dT", + "RV9OT0RFX0NMQVNTX0RUT19PQkpFQ1QQARIiCh5CUk9XU0VfTk9ERV9DTEFT", + "U19EVE9fVkFSSUFCTEUQAhIgChxCUk9XU0VfTk9ERV9DTEFTU19EVE9fTUVU", + "SE9EEAMSHwobQlJPV1NFX05PREVfQ0xBU1NfRFRPX09USEVSEAQqoQIKFEJy", + "b3dzZUZhaWx1cmVLaW5kRHRvEicKI0JST1dTRV9GQUlMVVJFX0tJTkRfRFRP", + "X1VOU1BFQ0lGSUVEEAASMAosQlJPV1NFX0ZBSUxVUkVfS0lORF9EVE9fQ09O", + "TkVDVElPTl9OT1RfRk9VTkQQARI0CjBCUk9XU0VfRkFJTFVSRV9LSU5EX0RU", + "T19DT05ORUNUSU9OX05PVF9DT05ORUNURUQQAhIpCiVCUk9XU0VfRkFJTFVS", + "RV9LSU5EX0RUT19OT1RfQlJPV1NBQkxFEAMSIwofQlJPV1NFX0ZBSUxVUkVf", + "S0lORF9EVE9fVElNRU9VVBAEEigKJEJST1dTRV9GQUlMVVJFX0tJTkRfRFRP", + "X1NFUlZFUl9FUlJPUhAFKqoCChtSZWFkVGFnVmFsdWVzRmFpbHVyZUtpbmRE", + "dG8SMAosUkVBRF9UQUdfVkFMVUVTX0ZBSUxVUkVfS0lORF9EVE9fVU5TUEVD", + "SUZJRUQQABI5CjVSRUFEX1RBR19WQUxVRVNfRkFJTFVSRV9LSU5EX0RUT19D", + "T05ORUNUSU9OX05PVF9GT1VORBABEj0KOVJFQURfVEFHX1ZBTFVFU19GQUlM", + "VVJFX0tJTkRfRFRPX0NPTk5FQ1RJT05fTk9UX0NPTk5FQ1RFRBACEiwKKFJF", + "QURfVEFHX1ZBTFVFU19GQUlMVVJFX0tJTkRfRFRPX1RJTUVPVVQQAxIxCi1S", + "RUFEX1RBR19WQUxVRVNfRkFJTFVSRV9LSU5EX0RUT19TRVJWRVJfRVJST1IQ", + "BCqTAgoUVmVyaWZ5RmFpbHVyZUtpbmREdG8SJwojVkVSSUZZX0ZBSUxVUkVf", + "S0lORF9EVE9fVU5TUEVDSUZJRUQQABInCiNWRVJJRllfRkFJTFVSRV9LSU5E", + "X0RUT19VTlJFQUNIQUJMRRABEicKI1ZFUklGWV9GQUlMVVJFX0tJTkRfRFRP", + "X0FVVEhfRkFJTEVEEAISMQotVkVSSUZZX0ZBSUxVUkVfS0lORF9EVE9fVU5U", + "UlVTVEVEX0NFUlRJRklDQVRFEAMSIwofVkVSSUZZX0ZBSUxVUkVfS0lORF9E", + "VE9fVElNRU9VVBAEEigKJFZFUklGWV9GQUlMVVJFX0tJTkRfRFRPX1NFUlZF", + "Ul9FUlJPUhAFKuUBChpTdG9yZUFuZEZvcndhcmRDYXRlZ29yeUR0bxIuCipT", + "VE9SRV9BTkRfRk9SV0FSRF9DQVRFR09SWV9EVE9fVU5TUEVDSUZJRUQQABIy", + "Ci5TVE9SRV9BTkRfRk9SV0FSRF9DQVRFR09SWV9EVE9fRVhURVJOQUxfU1lT", + "VEVNEAESLworU1RPUkVfQU5EX0ZPUldBUkRfQ0FURUdPUllfRFRPX05PVElG", + "SUNBVElPThACEjIKLlNUT1JFX0FORF9GT1JXQVJEX0NBVEVHT1JZX0RUT19D", + "QUNIRURfREJfV1JJVEUQAypoCg1BbGFybVN0YXRlRHRvEh8KG0FMQVJNX1NU", + "QVRFX0RUT19VTlNQRUNJRklFRBAAEhoKFkFMQVJNX1NUQVRFX0RUT19BQ1RJ", + "VkUQARIaChZBTEFSTV9TVEFURV9EVE9fTk9STUFMEAIquQEKDUFsYXJtTGV2", + "ZWxEdG8SHwobQUxBUk1fTEVWRUxfRFRPX1VOU1BFQ0lGSUVEEAASGAoUQUxB", + "Uk1fTEVWRUxfRFRPX05PTkUQARIXChNBTEFSTV9MRVZFTF9EVE9fTE9XEAIS", + "GwoXQUxBUk1fTEVWRUxfRFRPX0xPV19MT1cQAxIYChRBTEFSTV9MRVZFTF9E", + "VE9fSElHSBAEEh0KGUFMQVJNX0xFVkVMX0RUT19ISUdIX0hJR0gQBSqSAQoM", + "QWxhcm1LaW5kRHRvEh4KGkFMQVJNX0tJTkRfRFRPX1VOU1BFQ0lGSUVEEAAS", + "GwoXQUxBUk1fS0lORF9EVE9fQ09NUFVURUQQARIgChxBTEFSTV9LSU5EX0RU", + "T19OQVRJVkVfT1BDX1VBEAISIwofQUxBUk1fS0lORF9EVE9fTkFUSVZFX01Y", + "X0FDQ0VTUxADKugBChNBbGFybVNoZWx2ZVN0YXRlRHRvEiYKIkFMQVJNX1NI", + "RUxWRV9TVEFURV9EVE9fVU5TUEVDSUZJRUQQABIkCiBBTEFSTV9TSEVMVkVf", + "U1RBVEVfRFRPX1VOU0hFTFZFRBABEisKJ0FMQVJNX1NIRUxWRV9TVEFURV9E", + "VE9fT05FX1NIT1RfU0hFTFZFRBACEigKJEFMQVJNX1NIRUxWRV9TVEFURV9E", + "VE9fVElNRURfU0hFTFZFRBADEiwKKEFMQVJNX1NIRUxWRV9TVEFURV9EVE9f", + "UEVSTUFORU5UX1NIRUxWRUQQBDKEBQoSU2l0ZUNvbW1hbmRTZXJ2aWNlEmwK", + "EEV4ZWN1dGVMaWZlY3ljbGUSLC5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52", + "MS5MaWZlY3ljbGVSZXF1ZXN0Giouc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQu", + "djEuTGlmZWN5Y2xlUmVwbHkSYAoMRXhlY3V0ZU9wY1VhEiguc2NhZGFicmlk", + "Z2Uuc2l0ZWNvbW1hbmQudjEuT3BjVWFSZXF1ZXN0GiYuc2NhZGFicmlkZ2Uu", + "c2l0ZWNvbW1hbmQudjEuT3BjVWFSZXBseRJgCgxFeGVjdXRlUXVlcnkSKC5z", + "Y2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5RdWVyeVJlcXVlc3QaJi5zY2Fk", + "YWJyaWRnZS5zaXRlY29tbWFuZC52MS5RdWVyeVJlcGx5EmMKDUV4ZWN1dGVQ", + "YXJrZWQSKS5zY2FkYWJyaWRnZS5zaXRlY29tbWFuZC52MS5QYXJrZWRSZXF1", + "ZXN0Gicuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUGFya2VkUmVwbHkS", + "YAoMRXhlY3V0ZVJvdXRlEiguc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEu", + "Um91dGVSZXF1ZXN0GiYuc2NhZGFicmlkZ2Uuc2l0ZWNvbW1hbmQudjEuUm91", + "dGVSZXBseRJ1Cg9UcmlnZ2VyRmFpbG92ZXISMi5zY2FkYWJyaWRnZS5zaXRl", + "Y29tbWFuZC52MS5UcmlnZ2VyU2l0ZUZhaWxvdmVyRHRvGi4uc2NhZGFicmlk", + "Z2Uuc2l0ZWNvbW1hbmQudjEuU2l0ZUZhaWxvdmVyQWNrRHRvQiuqAihaQi5N", + "T00uV1cuU2NhZGFCcmlkZ2UuQ29tbXVuaWNhdGlvbi5HcnBjYgZwcm90bzM=")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::Google.Protobuf.WellKnownTypes.TimestampReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.DurationReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.WrappersReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto), typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap.Parser, new[]{ "Entries" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue.Parser, new[]{ "NullValue", "BoolValue", "Int32Value", "Int64Value", "DoubleValue", "FloatValue", "StringValue", "DecimalValue", "DateTimeValue", "DateTimeOffsetValue", "GuidValue", "TimeSpanValue", "BytesValue", "ListValue", "MapValue", "JsonValue" }, new[]{ "Kind" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto.Parser, new[]{ "DeploymentId", "InstanceUniqueName", "RevisionHash", "DeployedBy", "Timestamp", "CentralFetchBaseUrl", "FetchToken" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto.Parser, new[]{ "CommandId", "InstanceUniqueName", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto.Parser, new[]{ "CommandId", "InstanceUniqueName", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto.Parser, new[]{ "CommandId", "InstanceUniqueName", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactDto.Parser, new[]{ "Name", "Code", "ParameterDefinitions", "ReturnDefinition" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactDto.Parser, new[]{ "Name", "EndpointUrl", "AuthType", "AuthConfiguration", "MethodDefinitionsJson", "TimeoutSeconds" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactDto.Parser, new[]{ "Name", "ConnectionString", "MaxRetries", "RetryDelay" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactDto.Parser, new[]{ "Name", "RecipientEmails" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactDto.Parser, new[]{ "Name", "Protocol", "PrimaryConfigurationJson", "BackupConfigurationJson", "FailoverRetryCount" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactDto.Parser, new[]{ "Name", "Server", "Port", "AuthMode", "FromAddress", "Username", "Password", "OauthConfig" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto.Parser, new[]{ "DeploymentId", "SharedScripts", "ExternalSystems", "DatabaseConnections", "NotificationLists", "DataConnections", "SmtpConfigurations", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto.Parser, new[]{ "DeploymentId", "InstanceUniqueName", "Status", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto.Parser, new[]{ "CommandId", "InstanceUniqueName", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "IsDeployed", "AppliedDeploymentId", "AppliedRevisionHash", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto.Parser, new[]{ "DeploymentId", "SiteId", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest.Parser, new[]{ "RefreshDeployment", "EnableInstance", "DisableInstance", "DeleteInstance", "DeploymentStateQuery", "DeployArtifacts" }, new[]{ "Command" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleReply), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleReply.Parser, new[]{ "DeploymentStatus", "InstanceLifecycle", "DeploymentStateQuery", "ArtifactDeployment" }, new[]{ "Reply" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto.Parser, new[]{ "ConnectionName", "ParentNodeId", "ContinuationToken", "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto.Parser, new[]{ "NodeId", "DisplayName", "NodeClass", "HasChildren", "DataType", "ValueRank", "Writable" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto.Parser, new[]{ "Kind", "Message" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto.Parser, new[]{ "Children", "Truncated", "Failure", "ContinuationToken" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto.Parser, new[]{ "ConnectionName", "Query", "MaxDepth", "MaxResults", "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AddressSpaceMatchDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AddressSpaceMatchDto.Parser, new[]{ "Node", "Path" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto.Parser, new[]{ "Matches", "CapReached", "Failure" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto.Parser, new[]{ "ConnectionName", "TagPaths" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TagReadOutcomeDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TagReadOutcomeDto.Parser, new[]{ "TagPath", "Success", "Value", "Quality", "Timestamp", "ErrorMessage" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto.Parser, new[]{ "Kind", "Message" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto.Parser, new[]{ "Outcomes", "Failure" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto.Parser, new[]{ "ConnectionName", "Protocol", "ConfigJson", "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto.Parser, new[]{ "Thumbprint", "Subject", "Issuer", "NotBeforeUtc", "NotAfterUtc", "DerBase64" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue.Parser, new[]{ "Value" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto.Parser, new[]{ "Success", "FailureKind", "Error", "Cert" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto.Parser, new[]{ "ConnectionName", "DerBase64", "Thumbprint", "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto.Parser, new[]{ "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto.Parser, new[]{ "Thumbprint", "SiteIdentifier" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoDto.Parser, new[]{ "Thumbprint", "Subject", "Issuer", "NotBeforeUtc", "NotAfterUtc", "Rejected" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto.Parser, new[]{ "Items" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto.Parser, new[]{ "Success", "Error", "Certs" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto.Parser, new[]{ "CorrelationId", "ConnectionName", "TagPath", "Value", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto.Parser, new[]{ "CorrelationId", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest.Parser, new[]{ "BrowseNode", "SearchAddressSpace", "ReadTagValues", "VerifyEndpoint", "TrustServerCert", "ListServerCerts", "RemoveServerCert", "WriteTag" }, new[]{ "Command" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaReply), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaReply.Parser, new[]{ "BrowseNode", "SearchAddressSpace", "ReadTagValues", "VerifyEndpoint", "CertTrust", "WriteTag" }, new[]{ "Reply" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto.Parser, new[]{ "CorrelationId", "SiteId", "From", "To", "EventType", "Severity", "InstanceId", "KeywordFilter", "ContinuationToken", "PageSize", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogEntryDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogEntryDto.Parser, new[]{ "Id", "Timestamp", "EventType", "Severity", "InstanceId", "Source", "Message", "Details" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto.Parser, new[]{ "CorrelationId", "SiteId", "Entries", "ContinuationToken", "HasMore", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto.Parser, new[]{ "InstanceUniqueName", "CorrelationId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto.Parser, new[]{ "InstanceUniqueName", "CorrelationId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto.Parser, new[]{ "InstanceUniqueName", "CorrelationId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto.Parser, new[]{ "Active", "Acknowledged", "Confirmed", "Shelve", "Suppressed", "Severity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAttributeValueDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAttributeValueDto.Parser, new[]{ "InstanceUniqueName", "AttributePath", "AttributeName", "Value", "Quality", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAlarmStateDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAlarmStateDto.Parser, new[]{ "InstanceUniqueName", "AlarmName", "State", "Priority", "Timestamp", "Level", "Message", "Kind", "Condition", "SourceReference", "AlarmTypeName", "Category", "OperatorUser", "OperatorComment", "OriginalRaiseTime", "CurrentValue", "LimitValue", "NativeSourceCanonicalName", "IsConfiguredPlaceholder" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto.Parser, new[]{ "InstanceUniqueName", "AttributeValues", "AlarmStates", "SnapshotTimestamp", "InstanceNotFound" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest.Parser, new[]{ "EventLogQuery", "DebugSnapshot", "SubscribeDebugView", "UnsubscribeDebugView" }, new[]{ "Command" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryReply), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryReply.Parser, new[]{ "EventLogQuery", "DebugViewSnapshot", "UnsubscribeDebugView" }, new[]{ "Reply" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto.Parser, new[]{ "CorrelationId", "SiteId", "PageNumber", "PageSize", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageEntryDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageEntryDto.Parser, new[]{ "MessageId", "TargetSystem", "MethodName", "ErrorMessage", "AttemptCount", "OriginalTimestamp", "LastAttemptTimestamp", "MaxAttempts", "Category", "OriginInstance" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto.Parser, new[]{ "CorrelationId", "SiteId", "Messages", "TotalCount", "PageNumber", "PageSize", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto.Parser, new[]{ "CorrelationId", "SiteId", "MessageId", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto.Parser, new[]{ "CorrelationId", "Success", "ErrorMessage" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto.Parser, new[]{ "CorrelationId", "SiteId", "MessageId", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto.Parser, new[]{ "CorrelationId", "Success", "ErrorMessage" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto.Parser, new[]{ "CorrelationId", "TrackedOperationId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto.Parser, new[]{ "CorrelationId", "TrackedOperationId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto.Parser, new[]{ "CorrelationId", "Applied", "ErrorMessage" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest.Parser, new[]{ "ParkedMessageQuery", "ParkedMessageRetry", "ParkedMessageDiscard", "RetryParkedOperation", "DiscardParkedOperation" }, new[]{ "Command" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedReply), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedReply.Parser, new[]{ "ParkedMessageQuery", "ParkedMessageRetry", "ParkedMessageDiscard", "ParkedOperationAction" }, new[]{ "Reply" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "ScriptName", "Parameters", "Timestamp", "ParentExecutionId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto.Parser, new[]{ "CorrelationId", "Success", "ReturnValue", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "AttributeNames", "Timestamp", "ParentExecutionId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto.Parser, new[]{ "CorrelationId", "Values", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "AttributeValues", "Timestamp", "ParentExecutionId" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto.Parser, new[]{ "CorrelationId", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto.Parser, new[]{ "CorrelationId", "InstanceUniqueName", "AttributeName", "TargetValueEncoded", "Timeout", "Timestamp", "ParentExecutionId", "RequireGoodQuality" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto.Parser, new[]{ "CorrelationId", "Matched", "Value", "Quality", "TimedOut", "Success", "ErrorMessage", "Timestamp" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest.Parser, new[]{ "RouteToCall", "RouteToGetAttributes", "RouteToSetAttributes", "RouteToWaitForAttribute" }, new[]{ "Command" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteReply), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteReply.Parser, new[]{ "RouteToCall", "RouteToGetAttributes", "RouteToSetAttributes", "RouteToWaitForAttribute" }, new[]{ "Reply" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto.Parser, new[]{ "CorrelationId", "SiteId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteFailoverAckDto), global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteFailoverAckDto.Parser, new[]{ "CorrelationId", "Accepted", "TargetAddress", "ErrorMessage" }, null, null, null, null) + })); + } + #endregion + + } + #region Enums + public enum DeploymentStatusDto { + [pbr::OriginalName("DEPLOYMENT_STATUS_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("DEPLOYMENT_STATUS_DTO_PENDING")] Pending = 1, + [pbr::OriginalName("DEPLOYMENT_STATUS_DTO_IN_PROGRESS")] InProgress = 2, + [pbr::OriginalName("DEPLOYMENT_STATUS_DTO_SUCCESS")] Success = 3, + [pbr::OriginalName("DEPLOYMENT_STATUS_DTO_FAILED")] Failed = 4, + } + + public enum BrowseNodeClassDto { + [pbr::OriginalName("BROWSE_NODE_CLASS_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("BROWSE_NODE_CLASS_DTO_OBJECT")] Object = 1, + [pbr::OriginalName("BROWSE_NODE_CLASS_DTO_VARIABLE")] Variable = 2, + [pbr::OriginalName("BROWSE_NODE_CLASS_DTO_METHOD")] Method = 3, + [pbr::OriginalName("BROWSE_NODE_CLASS_DTO_OTHER")] Other = 4, + } + + public enum BrowseFailureKindDto { + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_CONNECTION_NOT_FOUND")] ConnectionNotFound = 1, + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_CONNECTION_NOT_CONNECTED")] ConnectionNotConnected = 2, + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_NOT_BROWSABLE")] NotBrowsable = 3, + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_TIMEOUT")] Timeout = 4, + [pbr::OriginalName("BROWSE_FAILURE_KIND_DTO_SERVER_ERROR")] ServerError = 5, + } + + public enum ReadTagValuesFailureKindDto { + [pbr::OriginalName("READ_TAG_VALUES_FAILURE_KIND_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("READ_TAG_VALUES_FAILURE_KIND_DTO_CONNECTION_NOT_FOUND")] ConnectionNotFound = 1, + [pbr::OriginalName("READ_TAG_VALUES_FAILURE_KIND_DTO_CONNECTION_NOT_CONNECTED")] ConnectionNotConnected = 2, + [pbr::OriginalName("READ_TAG_VALUES_FAILURE_KIND_DTO_TIMEOUT")] Timeout = 3, + [pbr::OriginalName("READ_TAG_VALUES_FAILURE_KIND_DTO_SERVER_ERROR")] ServerError = 4, + } + + public enum VerifyFailureKindDto { + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_UNREACHABLE")] Unreachable = 1, + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_AUTH_FAILED")] AuthFailed = 2, + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_UNTRUSTED_CERTIFICATE")] UntrustedCertificate = 3, + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_TIMEOUT")] Timeout = 4, + [pbr::OriginalName("VERIFY_FAILURE_KIND_DTO_SERVER_ERROR")] ServerError = 5, + } + + public enum StoreAndForwardCategoryDto { + [pbr::OriginalName("STORE_AND_FORWARD_CATEGORY_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("STORE_AND_FORWARD_CATEGORY_DTO_EXTERNAL_SYSTEM")] ExternalSystem = 1, + [pbr::OriginalName("STORE_AND_FORWARD_CATEGORY_DTO_NOTIFICATION")] Notification = 2, + [pbr::OriginalName("STORE_AND_FORWARD_CATEGORY_DTO_CACHED_DB_WRITE")] CachedDbWrite = 3, + } + + public enum AlarmStateDto { + [pbr::OriginalName("ALARM_STATE_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("ALARM_STATE_DTO_ACTIVE")] Active = 1, + [pbr::OriginalName("ALARM_STATE_DTO_NORMAL")] Normal = 2, + } + + public enum AlarmLevelDto { + [pbr::OriginalName("ALARM_LEVEL_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("ALARM_LEVEL_DTO_NONE")] None = 1, + [pbr::OriginalName("ALARM_LEVEL_DTO_LOW")] Low = 2, + [pbr::OriginalName("ALARM_LEVEL_DTO_LOW_LOW")] LowLow = 3, + [pbr::OriginalName("ALARM_LEVEL_DTO_HIGH")] High = 4, + [pbr::OriginalName("ALARM_LEVEL_DTO_HIGH_HIGH")] HighHigh = 5, + } + + public enum AlarmKindDto { + [pbr::OriginalName("ALARM_KIND_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("ALARM_KIND_DTO_COMPUTED")] Computed = 1, + [pbr::OriginalName("ALARM_KIND_DTO_NATIVE_OPC_UA")] NativeOpcUa = 2, + [pbr::OriginalName("ALARM_KIND_DTO_NATIVE_MX_ACCESS")] NativeMxAccess = 3, + } + + public enum AlarmShelveStateDto { + [pbr::OriginalName("ALARM_SHELVE_STATE_DTO_UNSPECIFIED")] Unspecified = 0, + [pbr::OriginalName("ALARM_SHELVE_STATE_DTO_UNSHELVED")] Unshelved = 1, + [pbr::OriginalName("ALARM_SHELVE_STATE_DTO_ONE_SHOT_SHELVED")] OneShotShelved = 2, + [pbr::OriginalName("ALARM_SHELVE_STATE_DTO_TIMED_SHELVED")] TimedShelved = 3, + [pbr::OriginalName("ALARM_SHELVE_STATE_DTO_PERMANENT_SHELVED")] PermanentShelved = 4, + } + + #endregion + + #region Messages + /// + /// Explicit null marker. Needed because a map<string, LooseValue> entry always + /// has a value message present, so "the dictionary holds a null for this key" + /// cannot be expressed by absence the way a nullable message FIELD can. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LooseNull : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LooseNull()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseNull() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseNull(LooseNull other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseNull Clone() { + return new LooseNull(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LooseNull); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LooseNull other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LooseNull other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LooseValueList : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LooseValueList()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueList() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueList(LooseValueList other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueList Clone() { + return new LooseValueList(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LooseValueList); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LooseValueList other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LooseValueList other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LooseValueMap : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LooseValueMap()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueMap() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueMap(LooseValueMap other) : this() { + entries_ = other.entries_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValueMap Clone() { + return new LooseValueMap(this); + } + + /// Field number for the "entries" field. + public const int EntriesFieldNumber = 1; + private static readonly pbc::MapField.Codec _map_entries_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue.Parser), 10); + private readonly pbc::MapField entries_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Entries { + get { return entries_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LooseValueMap); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LooseValueMap other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Entries.Equals(other.Entries)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= Entries.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + entries_.WriteTo(output, _map_entries_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + entries_.WriteTo(ref output, _map_entries_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += entries_.CalculateSize(_map_entries_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LooseValueMap other) { + if (other == null) { + return; + } + entries_.MergeFrom(other.entries_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + entries_.AddEntriesFrom(input, _map_entries_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + entries_.AddEntriesFrom(ref input, _map_entries_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Type-tagged carrier for the `object?` members the command plane still uses + /// (script parameters and return values, attribute values, tag read/write + /// values). The tags cover every CLR type these fields actually carry, so those + /// values round-trip with their runtime type intact; anything else falls back to + /// `json_value` (see the mapper's documented lossiness note). + /// + /// Date/time and decimal ride as invariant round-trip STRINGS rather than + /// google.protobuf.Timestamp: Timestamp normalises everything to UTC and would + /// silently drop DateTime.Kind / DateTimeOffset.Offset, which for an operator's + /// tag value is data loss, not normalisation. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LooseValue : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LooseValue()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValue() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValue(LooseValue other) : this() { + switch (other.KindCase) { + case KindOneofCase.NullValue: + NullValue = other.NullValue.Clone(); + break; + case KindOneofCase.BoolValue: + BoolValue = other.BoolValue; + break; + case KindOneofCase.Int32Value: + Int32Value = other.Int32Value; + break; + case KindOneofCase.Int64Value: + Int64Value = other.Int64Value; + break; + case KindOneofCase.DoubleValue: + DoubleValue = other.DoubleValue; + break; + case KindOneofCase.FloatValue: + FloatValue = other.FloatValue; + break; + case KindOneofCase.StringValue: + StringValue = other.StringValue; + break; + case KindOneofCase.DecimalValue: + DecimalValue = other.DecimalValue; + break; + case KindOneofCase.DateTimeValue: + DateTimeValue = other.DateTimeValue; + break; + case KindOneofCase.DateTimeOffsetValue: + DateTimeOffsetValue = other.DateTimeOffsetValue; + break; + case KindOneofCase.GuidValue: + GuidValue = other.GuidValue; + break; + case KindOneofCase.TimeSpanValue: + TimeSpanValue = other.TimeSpanValue; + break; + case KindOneofCase.BytesValue: + BytesValue = other.BytesValue; + break; + case KindOneofCase.ListValue: + ListValue = other.ListValue.Clone(); + break; + case KindOneofCase.MapValue: + MapValue = other.MapValue.Clone(); + break; + case KindOneofCase.JsonValue: + JsonValue = other.JsonValue; + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LooseValue Clone() { + return new LooseValue(this); + } + + /// Field number for the "null_value" field. + public const int NullValueFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull NullValue { + get { return kindCase_ == KindOneofCase.NullValue ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull) kind_ : null; } + set { + kind_ = value; + kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.NullValue; + } + } + + /// Field number for the "bool_value" field. + public const int BoolValueFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool BoolValue { + get { return HasBoolValue ? (bool) kind_ : false; } + set { + kind_ = value; + kindCase_ = KindOneofCase.BoolValue; + } + } + /// Gets whether the "bool_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasBoolValue { + get { return kindCase_ == KindOneofCase.BoolValue; } + } + /// Clears the value of the oneof if it's currently set to "bool_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearBoolValue() { + if (HasBoolValue) { + ClearKind(); + } + } + + /// Field number for the "int32_value" field. + public const int Int32ValueFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Int32Value { + get { return HasInt32Value ? (int) kind_ : 0; } + set { + kind_ = value; + kindCase_ = KindOneofCase.Int32Value; + } + } + /// Gets whether the "int32_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasInt32Value { + get { return kindCase_ == KindOneofCase.Int32Value; } + } + /// Clears the value of the oneof if it's currently set to "int32_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearInt32Value() { + if (HasInt32Value) { + ClearKind(); + } + } + + /// Field number for the "int64_value" field. + public const int Int64ValueFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Int64Value { + get { return HasInt64Value ? (long) kind_ : 0L; } + set { + kind_ = value; + kindCase_ = KindOneofCase.Int64Value; + } + } + /// Gets whether the "int64_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasInt64Value { + get { return kindCase_ == KindOneofCase.Int64Value; } + } + /// Clears the value of the oneof if it's currently set to "int64_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearInt64Value() { + if (HasInt64Value) { + ClearKind(); + } + } + + /// Field number for the "double_value" field. + public const int DoubleValueFieldNumber = 5; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public double DoubleValue { + get { return HasDoubleValue ? (double) kind_ : 0D; } + set { + kind_ = value; + kindCase_ = KindOneofCase.DoubleValue; + } + } + /// Gets whether the "double_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDoubleValue { + get { return kindCase_ == KindOneofCase.DoubleValue; } + } + /// Clears the value of the oneof if it's currently set to "double_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDoubleValue() { + if (HasDoubleValue) { + ClearKind(); + } + } + + /// Field number for the "float_value" field. + public const int FloatValueFieldNumber = 6; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public float FloatValue { + get { return HasFloatValue ? (float) kind_ : 0F; } + set { + kind_ = value; + kindCase_ = KindOneofCase.FloatValue; + } + } + /// Gets whether the "float_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasFloatValue { + get { return kindCase_ == KindOneofCase.FloatValue; } + } + /// Clears the value of the oneof if it's currently set to "float_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearFloatValue() { + if (HasFloatValue) { + ClearKind(); + } + } + + /// Field number for the "string_value" field. + public const int StringValueFieldNumber = 7; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StringValue { + get { return HasStringValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.StringValue; + } + } + /// Gets whether the "string_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStringValue { + get { return kindCase_ == KindOneofCase.StringValue; } + } + /// Clears the value of the oneof if it's currently set to "string_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStringValue() { + if (HasStringValue) { + ClearKind(); + } + } + + /// Field number for the "decimal_value" field. + public const int DecimalValueFieldNumber = 8; + /// + /// invariant-culture round-trip + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DecimalValue { + get { return HasDecimalValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.DecimalValue; + } + } + /// Gets whether the "decimal_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDecimalValue { + get { return kindCase_ == KindOneofCase.DecimalValue; } + } + /// Clears the value of the oneof if it's currently set to "decimal_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDecimalValue() { + if (HasDecimalValue) { + ClearKind(); + } + } + + /// Field number for the "date_time_value" field. + public const int DateTimeValueFieldNumber = 9; + /// + /// DateTime, "O" (preserves Kind) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DateTimeValue { + get { return HasDateTimeValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.DateTimeValue; + } + } + /// Gets whether the "date_time_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDateTimeValue { + get { return kindCase_ == KindOneofCase.DateTimeValue; } + } + /// Clears the value of the oneof if it's currently set to "date_time_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDateTimeValue() { + if (HasDateTimeValue) { + ClearKind(); + } + } + + /// Field number for the "date_time_offset_value" field. + public const int DateTimeOffsetValueFieldNumber = 10; + /// + /// DateTimeOffset, "O" (preserves Offset) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DateTimeOffsetValue { + get { return HasDateTimeOffsetValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.DateTimeOffsetValue; + } + } + /// Gets whether the "date_time_offset_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDateTimeOffsetValue { + get { return kindCase_ == KindOneofCase.DateTimeOffsetValue; } + } + /// Clears the value of the oneof if it's currently set to "date_time_offset_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDateTimeOffsetValue() { + if (HasDateTimeOffsetValue) { + ClearKind(); + } + } + + /// Field number for the "guid_value" field. + public const int GuidValueFieldNumber = 11; + /// + /// "D" + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string GuidValue { + get { return HasGuidValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.GuidValue; + } + } + /// Gets whether the "guid_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasGuidValue { + get { return kindCase_ == KindOneofCase.GuidValue; } + } + /// Clears the value of the oneof if it's currently set to "guid_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearGuidValue() { + if (HasGuidValue) { + ClearKind(); + } + } + + /// Field number for the "time_span_value" field. + public const int TimeSpanValueFieldNumber = 12; + /// + /// "c" (constant/round-trip) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TimeSpanValue { + get { return HasTimeSpanValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.TimeSpanValue; + } + } + /// Gets whether the "time_span_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTimeSpanValue { + get { return kindCase_ == KindOneofCase.TimeSpanValue; } + } + /// Clears the value of the oneof if it's currently set to "time_span_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTimeSpanValue() { + if (HasTimeSpanValue) { + ClearKind(); + } + } + + /// Field number for the "bytes_value" field. + public const int BytesValueFieldNumber = 13; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString BytesValue { + get { return HasBytesValue ? (pb::ByteString) kind_ : pb::ByteString.Empty; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.BytesValue; + } + } + /// Gets whether the "bytes_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasBytesValue { + get { return kindCase_ == KindOneofCase.BytesValue; } + } + /// Clears the value of the oneof if it's currently set to "bytes_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearBytesValue() { + if (HasBytesValue) { + ClearKind(); + } + } + + /// Field number for the "list_value" field. + public const int ListValueFieldNumber = 14; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList ListValue { + get { return kindCase_ == KindOneofCase.ListValue ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList) kind_ : null; } + set { + kind_ = value; + kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.ListValue; + } + } + + /// Field number for the "map_value" field. + public const int MapValueFieldNumber = 15; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap MapValue { + get { return kindCase_ == KindOneofCase.MapValue ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap) kind_ : null; } + set { + kind_ = value; + kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.MapValue; + } + } + + /// Field number for the "json_value" field. + public const int JsonValueFieldNumber = 16; + /// + /// fallback; decodes to JsonElement + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string JsonValue { + get { return HasJsonValue ? (string) kind_ : ""; } + set { + kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + kindCase_ = KindOneofCase.JsonValue; + } + } + /// Gets whether the "json_value" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasJsonValue { + get { return kindCase_ == KindOneofCase.JsonValue; } + } + /// Clears the value of the oneof if it's currently set to "json_value" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearJsonValue() { + if (HasJsonValue) { + ClearKind(); + } + } + + private object kind_; + /// Enum of possible cases for the "kind" oneof. + public enum KindOneofCase { + None = 0, + NullValue = 1, + BoolValue = 2, + Int32Value = 3, + Int64Value = 4, + DoubleValue = 5, + FloatValue = 6, + StringValue = 7, + DecimalValue = 8, + DateTimeValue = 9, + DateTimeOffsetValue = 10, + GuidValue = 11, + TimeSpanValue = 12, + BytesValue = 13, + ListValue = 14, + MapValue = 15, + JsonValue = 16, + } + private KindOneofCase kindCase_ = KindOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public KindOneofCase KindCase { + get { return kindCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearKind() { + kindCase_ = KindOneofCase.None; + kind_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LooseValue); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LooseValue other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(NullValue, other.NullValue)) return false; + if (BoolValue != other.BoolValue) return false; + if (Int32Value != other.Int32Value) return false; + if (Int64Value != other.Int64Value) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DoubleValue, other.DoubleValue)) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FloatValue, other.FloatValue)) return false; + if (StringValue != other.StringValue) return false; + if (DecimalValue != other.DecimalValue) return false; + if (DateTimeValue != other.DateTimeValue) return false; + if (DateTimeOffsetValue != other.DateTimeOffsetValue) return false; + if (GuidValue != other.GuidValue) return false; + if (TimeSpanValue != other.TimeSpanValue) return false; + if (BytesValue != other.BytesValue) return false; + if (!object.Equals(ListValue, other.ListValue)) return false; + if (!object.Equals(MapValue, other.MapValue)) return false; + if (JsonValue != other.JsonValue) return false; + if (KindCase != other.KindCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (kindCase_ == KindOneofCase.NullValue) hash ^= NullValue.GetHashCode(); + if (HasBoolValue) hash ^= BoolValue.GetHashCode(); + if (HasInt32Value) hash ^= Int32Value.GetHashCode(); + if (HasInt64Value) hash ^= Int64Value.GetHashCode(); + if (HasDoubleValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DoubleValue); + if (HasFloatValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FloatValue); + if (HasStringValue) hash ^= StringValue.GetHashCode(); + if (HasDecimalValue) hash ^= DecimalValue.GetHashCode(); + if (HasDateTimeValue) hash ^= DateTimeValue.GetHashCode(); + if (HasDateTimeOffsetValue) hash ^= DateTimeOffsetValue.GetHashCode(); + if (HasGuidValue) hash ^= GuidValue.GetHashCode(); + if (HasTimeSpanValue) hash ^= TimeSpanValue.GetHashCode(); + if (HasBytesValue) hash ^= BytesValue.GetHashCode(); + if (kindCase_ == KindOneofCase.ListValue) hash ^= ListValue.GetHashCode(); + if (kindCase_ == KindOneofCase.MapValue) hash ^= MapValue.GetHashCode(); + if (HasJsonValue) hash ^= JsonValue.GetHashCode(); + hash ^= (int) kindCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (kindCase_ == KindOneofCase.NullValue) { + output.WriteRawTag(10); + output.WriteMessage(NullValue); + } + if (HasBoolValue) { + output.WriteRawTag(16); + output.WriteBool(BoolValue); + } + if (HasInt32Value) { + output.WriteRawTag(24); + output.WriteInt32(Int32Value); + } + if (HasInt64Value) { + output.WriteRawTag(32); + output.WriteInt64(Int64Value); + } + if (HasDoubleValue) { + output.WriteRawTag(41); + output.WriteDouble(DoubleValue); + } + if (HasFloatValue) { + output.WriteRawTag(53); + output.WriteFloat(FloatValue); + } + if (HasStringValue) { + output.WriteRawTag(58); + output.WriteString(StringValue); + } + if (HasDecimalValue) { + output.WriteRawTag(66); + output.WriteString(DecimalValue); + } + if (HasDateTimeValue) { + output.WriteRawTag(74); + output.WriteString(DateTimeValue); + } + if (HasDateTimeOffsetValue) { + output.WriteRawTag(82); + output.WriteString(DateTimeOffsetValue); + } + if (HasGuidValue) { + output.WriteRawTag(90); + output.WriteString(GuidValue); + } + if (HasTimeSpanValue) { + output.WriteRawTag(98); + output.WriteString(TimeSpanValue); + } + if (HasBytesValue) { + output.WriteRawTag(106); + output.WriteBytes(BytesValue); + } + if (kindCase_ == KindOneofCase.ListValue) { + output.WriteRawTag(114); + output.WriteMessage(ListValue); + } + if (kindCase_ == KindOneofCase.MapValue) { + output.WriteRawTag(122); + output.WriteMessage(MapValue); + } + if (HasJsonValue) { + output.WriteRawTag(130, 1); + output.WriteString(JsonValue); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (kindCase_ == KindOneofCase.NullValue) { + output.WriteRawTag(10); + output.WriteMessage(NullValue); + } + if (HasBoolValue) { + output.WriteRawTag(16); + output.WriteBool(BoolValue); + } + if (HasInt32Value) { + output.WriteRawTag(24); + output.WriteInt32(Int32Value); + } + if (HasInt64Value) { + output.WriteRawTag(32); + output.WriteInt64(Int64Value); + } + if (HasDoubleValue) { + output.WriteRawTag(41); + output.WriteDouble(DoubleValue); + } + if (HasFloatValue) { + output.WriteRawTag(53); + output.WriteFloat(FloatValue); + } + if (HasStringValue) { + output.WriteRawTag(58); + output.WriteString(StringValue); + } + if (HasDecimalValue) { + output.WriteRawTag(66); + output.WriteString(DecimalValue); + } + if (HasDateTimeValue) { + output.WriteRawTag(74); + output.WriteString(DateTimeValue); + } + if (HasDateTimeOffsetValue) { + output.WriteRawTag(82); + output.WriteString(DateTimeOffsetValue); + } + if (HasGuidValue) { + output.WriteRawTag(90); + output.WriteString(GuidValue); + } + if (HasTimeSpanValue) { + output.WriteRawTag(98); + output.WriteString(TimeSpanValue); + } + if (HasBytesValue) { + output.WriteRawTag(106); + output.WriteBytes(BytesValue); + } + if (kindCase_ == KindOneofCase.ListValue) { + output.WriteRawTag(114); + output.WriteMessage(ListValue); + } + if (kindCase_ == KindOneofCase.MapValue) { + output.WriteRawTag(122); + output.WriteMessage(MapValue); + } + if (HasJsonValue) { + output.WriteRawTag(130, 1); + output.WriteString(JsonValue); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (kindCase_ == KindOneofCase.NullValue) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NullValue); + } + if (HasBoolValue) { + size += 1 + 1; + } + if (HasInt32Value) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Int32Value); + } + if (HasInt64Value) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Int64Value); + } + if (HasDoubleValue) { + size += 1 + 8; + } + if (HasFloatValue) { + size += 1 + 4; + } + if (HasStringValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue); + } + if (HasDecimalValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DecimalValue); + } + if (HasDateTimeValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DateTimeValue); + } + if (HasDateTimeOffsetValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DateTimeOffsetValue); + } + if (HasGuidValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GuidValue); + } + if (HasTimeSpanValue) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TimeSpanValue); + } + if (HasBytesValue) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(BytesValue); + } + if (kindCase_ == KindOneofCase.ListValue) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ListValue); + } + if (kindCase_ == KindOneofCase.MapValue) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(MapValue); + } + if (HasJsonValue) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(JsonValue); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LooseValue other) { + if (other == null) { + return; + } + switch (other.KindCase) { + case KindOneofCase.NullValue: + if (NullValue == null) { + NullValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull(); + } + NullValue.MergeFrom(other.NullValue); + break; + case KindOneofCase.BoolValue: + BoolValue = other.BoolValue; + break; + case KindOneofCase.Int32Value: + Int32Value = other.Int32Value; + break; + case KindOneofCase.Int64Value: + Int64Value = other.Int64Value; + break; + case KindOneofCase.DoubleValue: + DoubleValue = other.DoubleValue; + break; + case KindOneofCase.FloatValue: + FloatValue = other.FloatValue; + break; + case KindOneofCase.StringValue: + StringValue = other.StringValue; + break; + case KindOneofCase.DecimalValue: + DecimalValue = other.DecimalValue; + break; + case KindOneofCase.DateTimeValue: + DateTimeValue = other.DateTimeValue; + break; + case KindOneofCase.DateTimeOffsetValue: + DateTimeOffsetValue = other.DateTimeOffsetValue; + break; + case KindOneofCase.GuidValue: + GuidValue = other.GuidValue; + break; + case KindOneofCase.TimeSpanValue: + TimeSpanValue = other.TimeSpanValue; + break; + case KindOneofCase.BytesValue: + BytesValue = other.BytesValue; + break; + case KindOneofCase.ListValue: + if (ListValue == null) { + ListValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList(); + } + ListValue.MergeFrom(other.ListValue); + break; + case KindOneofCase.MapValue: + if (MapValue == null) { + MapValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + MapValue.MergeFrom(other.MapValue); + break; + case KindOneofCase.JsonValue: + JsonValue = other.JsonValue; + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull(); + if (kindCase_ == KindOneofCase.NullValue) { + subBuilder.MergeFrom(NullValue); + } + input.ReadMessage(subBuilder); + NullValue = subBuilder; + break; + } + case 16: { + BoolValue = input.ReadBool(); + break; + } + case 24: { + Int32Value = input.ReadInt32(); + break; + } + case 32: { + Int64Value = input.ReadInt64(); + break; + } + case 41: { + DoubleValue = input.ReadDouble(); + break; + } + case 53: { + FloatValue = input.ReadFloat(); + break; + } + case 58: { + StringValue = input.ReadString(); + break; + } + case 66: { + DecimalValue = input.ReadString(); + break; + } + case 74: { + DateTimeValue = input.ReadString(); + break; + } + case 82: { + DateTimeOffsetValue = input.ReadString(); + break; + } + case 90: { + GuidValue = input.ReadString(); + break; + } + case 98: { + TimeSpanValue = input.ReadString(); + break; + } + case 106: { + BytesValue = input.ReadBytes(); + break; + } + case 114: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList(); + if (kindCase_ == KindOneofCase.ListValue) { + subBuilder.MergeFrom(ListValue); + } + input.ReadMessage(subBuilder); + ListValue = subBuilder; + break; + } + case 122: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + if (kindCase_ == KindOneofCase.MapValue) { + subBuilder.MergeFrom(MapValue); + } + input.ReadMessage(subBuilder); + MapValue = subBuilder; + break; + } + case 130: { + JsonValue = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseNull(); + if (kindCase_ == KindOneofCase.NullValue) { + subBuilder.MergeFrom(NullValue); + } + input.ReadMessage(subBuilder); + NullValue = subBuilder; + break; + } + case 16: { + BoolValue = input.ReadBool(); + break; + } + case 24: { + Int32Value = input.ReadInt32(); + break; + } + case 32: { + Int64Value = input.ReadInt64(); + break; + } + case 41: { + DoubleValue = input.ReadDouble(); + break; + } + case 53: { + FloatValue = input.ReadFloat(); + break; + } + case 58: { + StringValue = input.ReadString(); + break; + } + case 66: { + DecimalValue = input.ReadString(); + break; + } + case 74: { + DateTimeValue = input.ReadString(); + break; + } + case 82: { + DateTimeOffsetValue = input.ReadString(); + break; + } + case 90: { + GuidValue = input.ReadString(); + break; + } + case 98: { + TimeSpanValue = input.ReadString(); + break; + } + case 106: { + BytesValue = input.ReadBytes(); + break; + } + case 114: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueList(); + if (kindCase_ == KindOneofCase.ListValue) { + subBuilder.MergeFrom(ListValue); + } + input.ReadMessage(subBuilder); + ListValue = subBuilder; + break; + } + case 122: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + if (kindCase_ == KindOneofCase.MapValue) { + subBuilder.MergeFrom(MapValue); + } + input.ReadMessage(subBuilder); + MapValue = subBuilder; + break; + } + case 130: { + JsonValue = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RefreshDeploymentCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RefreshDeploymentCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RefreshDeploymentCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RefreshDeploymentCommandDto(RefreshDeploymentCommandDto other) : this() { + deploymentId_ = other.deploymentId_; + instanceUniqueName_ = other.instanceUniqueName_; + revisionHash_ = other.revisionHash_; + deployedBy_ = other.deployedBy_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + centralFetchBaseUrl_ = other.centralFetchBaseUrl_; + fetchToken_ = other.fetchToken_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RefreshDeploymentCommandDto Clone() { + return new RefreshDeploymentCommandDto(this); + } + + /// Field number for the "deployment_id" field. + public const int DeploymentIdFieldNumber = 1; + private string deploymentId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DeploymentId { + get { return deploymentId_; } + set { + deploymentId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "revision_hash" field. + public const int RevisionHashFieldNumber = 3; + private string revisionHash_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string RevisionHash { + get { return revisionHash_; } + set { + revisionHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "deployed_by" field. + public const int DeployedByFieldNumber = 4; + private string deployedBy_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DeployedBy { + get { return deployedBy_; } + set { + deployedBy_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "central_fetch_base_url" field. + public const int CentralFetchBaseUrlFieldNumber = 6; + private string centralFetchBaseUrl_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CentralFetchBaseUrl { + get { return centralFetchBaseUrl_; } + set { + centralFetchBaseUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "fetch_token" field. + public const int FetchTokenFieldNumber = 7; + private string fetchToken_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string FetchToken { + get { return fetchToken_; } + set { + fetchToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RefreshDeploymentCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RefreshDeploymentCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DeploymentId != other.DeploymentId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (RevisionHash != other.RevisionHash) return false; + if (DeployedBy != other.DeployedBy) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (CentralFetchBaseUrl != other.CentralFetchBaseUrl) return false; + if (FetchToken != other.FetchToken) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (DeploymentId.Length != 0) hash ^= DeploymentId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (RevisionHash.Length != 0) hash ^= RevisionHash.GetHashCode(); + if (DeployedBy.Length != 0) hash ^= DeployedBy.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (CentralFetchBaseUrl.Length != 0) hash ^= CentralFetchBaseUrl.GetHashCode(); + if (FetchToken.Length != 0) hash ^= FetchToken.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (RevisionHash.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RevisionHash); + } + if (DeployedBy.Length != 0) { + output.WriteRawTag(34); + output.WriteString(DeployedBy); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (CentralFetchBaseUrl.Length != 0) { + output.WriteRawTag(50); + output.WriteString(CentralFetchBaseUrl); + } + if (FetchToken.Length != 0) { + output.WriteRawTag(58); + output.WriteString(FetchToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (RevisionHash.Length != 0) { + output.WriteRawTag(26); + output.WriteString(RevisionHash); + } + if (DeployedBy.Length != 0) { + output.WriteRawTag(34); + output.WriteString(DeployedBy); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (CentralFetchBaseUrl.Length != 0) { + output.WriteRawTag(50); + output.WriteString(CentralFetchBaseUrl); + } + if (FetchToken.Length != 0) { + output.WriteRawTag(58); + output.WriteString(FetchToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (DeploymentId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (RevisionHash.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(RevisionHash); + } + if (DeployedBy.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeployedBy); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (CentralFetchBaseUrl.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CentralFetchBaseUrl); + } + if (FetchToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(FetchToken); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RefreshDeploymentCommandDto other) { + if (other == null) { + return; + } + if (other.DeploymentId.Length != 0) { + DeploymentId = other.DeploymentId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.RevisionHash.Length != 0) { + RevisionHash = other.RevisionHash; + } + if (other.DeployedBy.Length != 0) { + DeployedBy = other.DeployedBy; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.CentralFetchBaseUrl.Length != 0) { + CentralFetchBaseUrl = other.CentralFetchBaseUrl; + } + if (other.FetchToken.Length != 0) { + FetchToken = other.FetchToken; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + RevisionHash = input.ReadString(); + break; + } + case 34: { + DeployedBy = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + CentralFetchBaseUrl = input.ReadString(); + break; + } + case 58: { + FetchToken = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + RevisionHash = input.ReadString(); + break; + } + case 34: { + DeployedBy = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + CentralFetchBaseUrl = input.ReadString(); + break; + } + case 58: { + FetchToken = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EnableInstanceCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EnableInstanceCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableInstanceCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableInstanceCommandDto(EnableInstanceCommandDto other) : this() { + commandId_ = other.commandId_; + instanceUniqueName_ = other.instanceUniqueName_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableInstanceCommandDto Clone() { + return new EnableInstanceCommandDto(this); + } + + /// Field number for the "command_id" field. + public const int CommandIdFieldNumber = 1; + private string commandId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CommandId { + get { return commandId_; } + set { + commandId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EnableInstanceCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EnableInstanceCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CommandId != other.CommandId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CommandId.Length != 0) hash ^= CommandId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CommandId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CommandId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EnableInstanceCommandDto other) { + if (other == null) { + return; + } + if (other.CommandId.Length != 0) { + CommandId = other.CommandId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DisableInstanceCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DisableInstanceCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DisableInstanceCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DisableInstanceCommandDto(DisableInstanceCommandDto other) : this() { + commandId_ = other.commandId_; + instanceUniqueName_ = other.instanceUniqueName_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DisableInstanceCommandDto Clone() { + return new DisableInstanceCommandDto(this); + } + + /// Field number for the "command_id" field. + public const int CommandIdFieldNumber = 1; + private string commandId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CommandId { + get { return commandId_; } + set { + commandId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DisableInstanceCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DisableInstanceCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CommandId != other.CommandId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CommandId.Length != 0) hash ^= CommandId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CommandId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CommandId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DisableInstanceCommandDto other) { + if (other == null) { + return; + } + if (other.CommandId.Length != 0) { + CommandId = other.CommandId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DeleteInstanceCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeleteInstanceCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeleteInstanceCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeleteInstanceCommandDto(DeleteInstanceCommandDto other) : this() { + commandId_ = other.commandId_; + instanceUniqueName_ = other.instanceUniqueName_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeleteInstanceCommandDto Clone() { + return new DeleteInstanceCommandDto(this); + } + + /// Field number for the "command_id" field. + public const int CommandIdFieldNumber = 1; + private string commandId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CommandId { + get { return commandId_; } + set { + commandId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DeleteInstanceCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DeleteInstanceCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CommandId != other.CommandId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CommandId.Length != 0) hash ^= CommandId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CommandId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CommandId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DeleteInstanceCommandDto other) { + if (other == null) { + return; + } + if (other.CommandId.Length != 0) { + CommandId = other.CommandId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DeploymentStateQueryRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeploymentStateQueryRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryRequestDto(DeploymentStateQueryRequestDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryRequestDto Clone() { + return new DeploymentStateQueryRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DeploymentStateQueryRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DeploymentStateQueryRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (timestamp_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DeploymentStateQueryRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SharedScriptArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SharedScriptArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactDto(SharedScriptArtifactDto other) : this() { + name_ = other.name_; + code_ = other.code_; + parameterDefinitions_ = other.parameterDefinitions_; + returnDefinition_ = other.returnDefinition_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactDto Clone() { + return new SharedScriptArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "code" field. + public const int CodeFieldNumber = 2; + private string code_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Code { + get { return code_; } + set { + code_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "parameter_definitions" field. + public const int ParameterDefinitionsFieldNumber = 3; + private string parameterDefinitions_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParameterDefinitions { + get { return parameterDefinitions_; } + set { + parameterDefinitions_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "return_definition" field. + public const int ReturnDefinitionFieldNumber = 4; + private string returnDefinition_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ReturnDefinition { + get { return returnDefinition_; } + set { + returnDefinition_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SharedScriptArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SharedScriptArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Code != other.Code) return false; + if (ParameterDefinitions != other.ParameterDefinitions) return false; + if (ReturnDefinition != other.ReturnDefinition) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Code.Length != 0) hash ^= Code.GetHashCode(); + if (ParameterDefinitions.Length != 0) hash ^= ParameterDefinitions.GetHashCode(); + if (ReturnDefinition.Length != 0) hash ^= ReturnDefinition.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Code.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Code); + } + if (ParameterDefinitions.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ParameterDefinitions); + } + if (ReturnDefinition.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ReturnDefinition); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Code.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Code); + } + if (ParameterDefinitions.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ParameterDefinitions); + } + if (ReturnDefinition.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ReturnDefinition); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Code.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Code); + } + if (ParameterDefinitions.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParameterDefinitions); + } + if (ReturnDefinition.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ReturnDefinition); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SharedScriptArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Code.Length != 0) { + Code = other.Code; + } + if (other.ParameterDefinitions.Length != 0) { + ParameterDefinitions = other.ParameterDefinitions; + } + if (other.ReturnDefinition.Length != 0) { + ReturnDefinition = other.ReturnDefinition; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Code = input.ReadString(); + break; + } + case 26: { + ParameterDefinitions = input.ReadString(); + break; + } + case 34: { + ReturnDefinition = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Code = input.ReadString(); + break; + } + case 26: { + ParameterDefinitions = input.ReadString(); + break; + } + case 34: { + ReturnDefinition = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ExternalSystemArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExternalSystemArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactDto(ExternalSystemArtifactDto other) : this() { + name_ = other.name_; + endpointUrl_ = other.endpointUrl_; + authType_ = other.authType_; + authConfiguration_ = other.authConfiguration_; + methodDefinitionsJson_ = other.methodDefinitionsJson_; + timeoutSeconds_ = other.timeoutSeconds_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactDto Clone() { + return new ExternalSystemArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "endpoint_url" field. + public const int EndpointUrlFieldNumber = 2; + private string endpointUrl_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string EndpointUrl { + get { return endpointUrl_; } + set { + endpointUrl_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "auth_type" field. + public const int AuthTypeFieldNumber = 3; + private string authType_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AuthType { + get { return authType_; } + set { + authType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "auth_configuration" field. + public const int AuthConfigurationFieldNumber = 4; + private string authConfiguration_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AuthConfiguration { + get { return authConfiguration_; } + set { + authConfiguration_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "method_definitions_json" field. + public const int MethodDefinitionsJsonFieldNumber = 5; + private string methodDefinitionsJson_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MethodDefinitionsJson { + get { return methodDefinitionsJson_; } + set { + methodDefinitionsJson_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timeout_seconds" field. + public const int TimeoutSecondsFieldNumber = 6; + private int timeoutSeconds_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int TimeoutSeconds { + get { return timeoutSeconds_; } + set { + timeoutSeconds_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ExternalSystemArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ExternalSystemArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (EndpointUrl != other.EndpointUrl) return false; + if (AuthType != other.AuthType) return false; + if (AuthConfiguration != other.AuthConfiguration) return false; + if (MethodDefinitionsJson != other.MethodDefinitionsJson) return false; + if (TimeoutSeconds != other.TimeoutSeconds) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (EndpointUrl.Length != 0) hash ^= EndpointUrl.GetHashCode(); + if (AuthType.Length != 0) hash ^= AuthType.GetHashCode(); + if (AuthConfiguration.Length != 0) hash ^= AuthConfiguration.GetHashCode(); + if (MethodDefinitionsJson.Length != 0) hash ^= MethodDefinitionsJson.GetHashCode(); + if (TimeoutSeconds != 0) hash ^= TimeoutSeconds.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (EndpointUrl.Length != 0) { + output.WriteRawTag(18); + output.WriteString(EndpointUrl); + } + if (AuthType.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AuthType); + } + if (AuthConfiguration.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AuthConfiguration); + } + if (MethodDefinitionsJson.Length != 0) { + output.WriteRawTag(42); + output.WriteString(MethodDefinitionsJson); + } + if (TimeoutSeconds != 0) { + output.WriteRawTag(48); + output.WriteInt32(TimeoutSeconds); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (EndpointUrl.Length != 0) { + output.WriteRawTag(18); + output.WriteString(EndpointUrl); + } + if (AuthType.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AuthType); + } + if (AuthConfiguration.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AuthConfiguration); + } + if (MethodDefinitionsJson.Length != 0) { + output.WriteRawTag(42); + output.WriteString(MethodDefinitionsJson); + } + if (TimeoutSeconds != 0) { + output.WriteRawTag(48); + output.WriteInt32(TimeoutSeconds); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (EndpointUrl.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(EndpointUrl); + } + if (AuthType.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AuthType); + } + if (AuthConfiguration.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AuthConfiguration); + } + if (MethodDefinitionsJson.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MethodDefinitionsJson); + } + if (TimeoutSeconds != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(TimeoutSeconds); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ExternalSystemArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.EndpointUrl.Length != 0) { + EndpointUrl = other.EndpointUrl; + } + if (other.AuthType.Length != 0) { + AuthType = other.AuthType; + } + if (other.AuthConfiguration.Length != 0) { + AuthConfiguration = other.AuthConfiguration; + } + if (other.MethodDefinitionsJson.Length != 0) { + MethodDefinitionsJson = other.MethodDefinitionsJson; + } + if (other.TimeoutSeconds != 0) { + TimeoutSeconds = other.TimeoutSeconds; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + EndpointUrl = input.ReadString(); + break; + } + case 26: { + AuthType = input.ReadString(); + break; + } + case 34: { + AuthConfiguration = input.ReadString(); + break; + } + case 42: { + MethodDefinitionsJson = input.ReadString(); + break; + } + case 48: { + TimeoutSeconds = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + EndpointUrl = input.ReadString(); + break; + } + case 26: { + AuthType = input.ReadString(); + break; + } + case 34: { + AuthConfiguration = input.ReadString(); + break; + } + case 42: { + MethodDefinitionsJson = input.ReadString(); + break; + } + case 48: { + TimeoutSeconds = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DatabaseConnectionArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DatabaseConnectionArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactDto(DatabaseConnectionArtifactDto other) : this() { + name_ = other.name_; + connectionString_ = other.connectionString_; + maxRetries_ = other.maxRetries_; + retryDelay_ = other.retryDelay_ != null ? other.retryDelay_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactDto Clone() { + return new DatabaseConnectionArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "connection_string" field. + public const int ConnectionStringFieldNumber = 2; + private string connectionString_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionString { + get { return connectionString_; } + set { + connectionString_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "max_retries" field. + public const int MaxRetriesFieldNumber = 3; + private int maxRetries_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int MaxRetries { + get { return maxRetries_; } + set { + maxRetries_ = value; + } + } + + /// Field number for the "retry_delay" field. + public const int RetryDelayFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Duration retryDelay_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Duration RetryDelay { + get { return retryDelay_; } + set { + retryDelay_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DatabaseConnectionArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DatabaseConnectionArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (ConnectionString != other.ConnectionString) return false; + if (MaxRetries != other.MaxRetries) return false; + if (!object.Equals(RetryDelay, other.RetryDelay)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (ConnectionString.Length != 0) hash ^= ConnectionString.GetHashCode(); + if (MaxRetries != 0) hash ^= MaxRetries.GetHashCode(); + if (retryDelay_ != null) hash ^= RetryDelay.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (ConnectionString.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ConnectionString); + } + if (MaxRetries != 0) { + output.WriteRawTag(24); + output.WriteInt32(MaxRetries); + } + if (retryDelay_ != null) { + output.WriteRawTag(34); + output.WriteMessage(RetryDelay); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (ConnectionString.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ConnectionString); + } + if (MaxRetries != 0) { + output.WriteRawTag(24); + output.WriteInt32(MaxRetries); + } + if (retryDelay_ != null) { + output.WriteRawTag(34); + output.WriteMessage(RetryDelay); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (ConnectionString.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionString); + } + if (MaxRetries != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxRetries); + } + if (retryDelay_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RetryDelay); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DatabaseConnectionArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.ConnectionString.Length != 0) { + ConnectionString = other.ConnectionString; + } + if (other.MaxRetries != 0) { + MaxRetries = other.MaxRetries; + } + if (other.retryDelay_ != null) { + if (retryDelay_ == null) { + RetryDelay = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + RetryDelay.MergeFrom(other.RetryDelay); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + ConnectionString = input.ReadString(); + break; + } + case 24: { + MaxRetries = input.ReadInt32(); + break; + } + case 34: { + if (retryDelay_ == null) { + RetryDelay = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(RetryDelay); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + ConnectionString = input.ReadString(); + break; + } + case 24: { + MaxRetries = input.ReadInt32(); + break; + } + case 34: { + if (retryDelay_ == null) { + RetryDelay = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(RetryDelay); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NotificationListArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NotificationListArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactDto(NotificationListArtifactDto other) : this() { + name_ = other.name_; + recipientEmails_ = other.recipientEmails_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactDto Clone() { + return new NotificationListArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "recipient_emails" field. + public const int RecipientEmailsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_recipientEmails_codec + = pb::FieldCodec.ForString(18); + private readonly pbc::RepeatedField recipientEmails_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField RecipientEmails { + get { return recipientEmails_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NotificationListArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NotificationListArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if(!recipientEmails_.Equals(other.recipientEmails_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + hash ^= recipientEmails_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + recipientEmails_.WriteTo(output, _repeated_recipientEmails_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + recipientEmails_.WriteTo(ref output, _repeated_recipientEmails_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + size += recipientEmails_.CalculateSize(_repeated_recipientEmails_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NotificationListArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + recipientEmails_.Add(other.recipientEmails_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + recipientEmails_.AddEntriesFrom(input, _repeated_recipientEmails_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + recipientEmails_.AddEntriesFrom(ref input, _repeated_recipientEmails_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataConnectionArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataConnectionArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactDto(DataConnectionArtifactDto other) : this() { + name_ = other.name_; + protocol_ = other.protocol_; + primaryConfigurationJson_ = other.primaryConfigurationJson_; + backupConfigurationJson_ = other.backupConfigurationJson_; + failoverRetryCount_ = other.failoverRetryCount_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactDto Clone() { + return new DataConnectionArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "protocol" field. + public const int ProtocolFieldNumber = 2; + private string protocol_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Protocol { + get { return protocol_; } + set { + protocol_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "primary_configuration_json" field. + public const int PrimaryConfigurationJsonFieldNumber = 3; + private string primaryConfigurationJson_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string PrimaryConfigurationJson { + get { return primaryConfigurationJson_; } + set { + primaryConfigurationJson_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "backup_configuration_json" field. + public const int BackupConfigurationJsonFieldNumber = 4; + private string backupConfigurationJson_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string BackupConfigurationJson { + get { return backupConfigurationJson_; } + set { + backupConfigurationJson_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "failover_retry_count" field. + public const int FailoverRetryCountFieldNumber = 5; + private int failoverRetryCount_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int FailoverRetryCount { + get { return failoverRetryCount_; } + set { + failoverRetryCount_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataConnectionArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataConnectionArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Protocol != other.Protocol) return false; + if (PrimaryConfigurationJson != other.PrimaryConfigurationJson) return false; + if (BackupConfigurationJson != other.BackupConfigurationJson) return false; + if (FailoverRetryCount != other.FailoverRetryCount) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Protocol.Length != 0) hash ^= Protocol.GetHashCode(); + if (PrimaryConfigurationJson.Length != 0) hash ^= PrimaryConfigurationJson.GetHashCode(); + if (BackupConfigurationJson.Length != 0) hash ^= BackupConfigurationJson.GetHashCode(); + if (FailoverRetryCount != 0) hash ^= FailoverRetryCount.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Protocol.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Protocol); + } + if (PrimaryConfigurationJson.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PrimaryConfigurationJson); + } + if (BackupConfigurationJson.Length != 0) { + output.WriteRawTag(34); + output.WriteString(BackupConfigurationJson); + } + if (FailoverRetryCount != 0) { + output.WriteRawTag(40); + output.WriteInt32(FailoverRetryCount); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Protocol.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Protocol); + } + if (PrimaryConfigurationJson.Length != 0) { + output.WriteRawTag(26); + output.WriteString(PrimaryConfigurationJson); + } + if (BackupConfigurationJson.Length != 0) { + output.WriteRawTag(34); + output.WriteString(BackupConfigurationJson); + } + if (FailoverRetryCount != 0) { + output.WriteRawTag(40); + output.WriteInt32(FailoverRetryCount); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Protocol.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Protocol); + } + if (PrimaryConfigurationJson.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PrimaryConfigurationJson); + } + if (BackupConfigurationJson.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(BackupConfigurationJson); + } + if (FailoverRetryCount != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(FailoverRetryCount); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataConnectionArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Protocol.Length != 0) { + Protocol = other.Protocol; + } + if (other.PrimaryConfigurationJson.Length != 0) { + PrimaryConfigurationJson = other.PrimaryConfigurationJson; + } + if (other.BackupConfigurationJson.Length != 0) { + BackupConfigurationJson = other.BackupConfigurationJson; + } + if (other.FailoverRetryCount != 0) { + FailoverRetryCount = other.FailoverRetryCount; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Protocol = input.ReadString(); + break; + } + case 26: { + PrimaryConfigurationJson = input.ReadString(); + break; + } + case 34: { + BackupConfigurationJson = input.ReadString(); + break; + } + case 40: { + FailoverRetryCount = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Protocol = input.ReadString(); + break; + } + case 26: { + PrimaryConfigurationJson = input.ReadString(); + break; + } + case 34: { + BackupConfigurationJson = input.ReadString(); + break; + } + case 40: { + FailoverRetryCount = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SmtpConfigurationArtifactDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SmtpConfigurationArtifactDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactDto(SmtpConfigurationArtifactDto other) : this() { + name_ = other.name_; + server_ = other.server_; + port_ = other.port_; + authMode_ = other.authMode_; + fromAddress_ = other.fromAddress_; + username_ = other.username_; + password_ = other.password_; + oauthConfig_ = other.oauthConfig_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactDto Clone() { + return new SmtpConfigurationArtifactDto(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private string name_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "server" field. + public const int ServerFieldNumber = 2; + private string server_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Server { + get { return server_; } + set { + server_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "port" field. + public const int PortFieldNumber = 3; + private int port_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Port { + get { return port_; } + set { + port_ = value; + } + } + + /// Field number for the "auth_mode" field. + public const int AuthModeFieldNumber = 4; + private string authMode_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AuthMode { + get { return authMode_; } + set { + authMode_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "from_address" field. + public const int FromAddressFieldNumber = 5; + private string fromAddress_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string FromAddress { + get { return fromAddress_; } + set { + fromAddress_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "username" field. + public const int UsernameFieldNumber = 6; + private string username_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Username { + get { return username_; } + set { + username_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "password" field. + public const int PasswordFieldNumber = 7; + private string password_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Password { + get { return password_; } + set { + password_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "oauth_config" field. + public const int OauthConfigFieldNumber = 8; + private string oauthConfig_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OauthConfig { + get { return oauthConfig_; } + set { + oauthConfig_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SmtpConfigurationArtifactDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SmtpConfigurationArtifactDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + if (Server != other.Server) return false; + if (Port != other.Port) return false; + if (AuthMode != other.AuthMode) return false; + if (FromAddress != other.FromAddress) return false; + if (Username != other.Username) return false; + if (Password != other.Password) return false; + if (OauthConfig != other.OauthConfig) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Name.Length != 0) hash ^= Name.GetHashCode(); + if (Server.Length != 0) hash ^= Server.GetHashCode(); + if (Port != 0) hash ^= Port.GetHashCode(); + if (AuthMode.Length != 0) hash ^= AuthMode.GetHashCode(); + if (FromAddress.Length != 0) hash ^= FromAddress.GetHashCode(); + if (Username.Length != 0) hash ^= Username.GetHashCode(); + if (Password.Length != 0) hash ^= Password.GetHashCode(); + if (OauthConfig.Length != 0) hash ^= OauthConfig.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Server.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Server); + } + if (Port != 0) { + output.WriteRawTag(24); + output.WriteInt32(Port); + } + if (AuthMode.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AuthMode); + } + if (FromAddress.Length != 0) { + output.WriteRawTag(42); + output.WriteString(FromAddress); + } + if (Username.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Username); + } + if (Password.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Password); + } + if (OauthConfig.Length != 0) { + output.WriteRawTag(66); + output.WriteString(OauthConfig); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Name.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (Server.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Server); + } + if (Port != 0) { + output.WriteRawTag(24); + output.WriteInt32(Port); + } + if (AuthMode.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AuthMode); + } + if (FromAddress.Length != 0) { + output.WriteRawTag(42); + output.WriteString(FromAddress); + } + if (Username.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Username); + } + if (Password.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Password); + } + if (OauthConfig.Length != 0) { + output.WriteRawTag(66); + output.WriteString(OauthConfig); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Name.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (Server.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Server); + } + if (Port != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Port); + } + if (AuthMode.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AuthMode); + } + if (FromAddress.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(FromAddress); + } + if (Username.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Username); + } + if (Password.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Password); + } + if (OauthConfig.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OauthConfig); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SmtpConfigurationArtifactDto other) { + if (other == null) { + return; + } + if (other.Name.Length != 0) { + Name = other.Name; + } + if (other.Server.Length != 0) { + Server = other.Server; + } + if (other.Port != 0) { + Port = other.Port; + } + if (other.AuthMode.Length != 0) { + AuthMode = other.AuthMode; + } + if (other.FromAddress.Length != 0) { + FromAddress = other.FromAddress; + } + if (other.Username.Length != 0) { + Username = other.Username; + } + if (other.Password.Length != 0) { + Password = other.Password; + } + if (other.OauthConfig.Length != 0) { + OauthConfig = other.OauthConfig; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Server = input.ReadString(); + break; + } + case 24: { + Port = input.ReadInt32(); + break; + } + case 34: { + AuthMode = input.ReadString(); + break; + } + case 42: { + FromAddress = input.ReadString(); + break; + } + case 50: { + Username = input.ReadString(); + break; + } + case 58: { + Password = input.ReadString(); + break; + } + case 66: { + OauthConfig = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Server = input.ReadString(); + break; + } + case 24: { + Port = input.ReadInt32(); + break; + } + case 34: { + AuthMode = input.ReadString(); + break; + } + case 42: { + FromAddress = input.ReadString(); + break; + } + case 50: { + Username = input.ReadString(); + break; + } + case 58: { + Password = input.ReadString(); + break; + } + case 66: { + OauthConfig = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// Each artifact collection on DeployArtifactsCommand is a NULLABLE list, and + /// proto3 `repeated` cannot distinguish null from empty. Wrapping each in its + /// own message makes the null/empty distinction a message-presence question, + /// which proto3 does model — the same silent-data-loss class the transport + /// round-trip guard caught in PLAN-05 T8. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SharedScriptArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SharedScriptArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactListDto(SharedScriptArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SharedScriptArtifactListDto Clone() { + return new SharedScriptArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SharedScriptArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SharedScriptArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SharedScriptArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ExternalSystemArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ExternalSystemArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactListDto(ExternalSystemArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ExternalSystemArtifactListDto Clone() { + return new ExternalSystemArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ExternalSystemArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ExternalSystemArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ExternalSystemArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DatabaseConnectionArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DatabaseConnectionArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactListDto(DatabaseConnectionArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DatabaseConnectionArtifactListDto Clone() { + return new DatabaseConnectionArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DatabaseConnectionArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DatabaseConnectionArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DatabaseConnectionArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NotificationListArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NotificationListArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactListDto(NotificationListArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NotificationListArtifactListDto Clone() { + return new NotificationListArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NotificationListArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NotificationListArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NotificationListArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataConnectionArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataConnectionArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactListDto(DataConnectionArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataConnectionArtifactListDto Clone() { + return new DataConnectionArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataConnectionArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataConnectionArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataConnectionArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SmtpConfigurationArtifactListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SmtpConfigurationArtifactListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactListDto(SmtpConfigurationArtifactListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SmtpConfigurationArtifactListDto Clone() { + return new SmtpConfigurationArtifactListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SmtpConfigurationArtifactListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SmtpConfigurationArtifactListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SmtpConfigurationArtifactListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DeployArtifactsCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeployArtifactsCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeployArtifactsCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeployArtifactsCommandDto(DeployArtifactsCommandDto other) : this() { + deploymentId_ = other.deploymentId_; + sharedScripts_ = other.sharedScripts_ != null ? other.sharedScripts_.Clone() : null; + externalSystems_ = other.externalSystems_ != null ? other.externalSystems_.Clone() : null; + databaseConnections_ = other.databaseConnections_ != null ? other.databaseConnections_.Clone() : null; + notificationLists_ = other.notificationLists_ != null ? other.notificationLists_.Clone() : null; + dataConnections_ = other.dataConnections_ != null ? other.dataConnections_.Clone() : null; + smtpConfigurations_ = other.smtpConfigurations_ != null ? other.smtpConfigurations_.Clone() : null; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeployArtifactsCommandDto Clone() { + return new DeployArtifactsCommandDto(this); + } + + /// Field number for the "deployment_id" field. + public const int DeploymentIdFieldNumber = 1; + private string deploymentId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DeploymentId { + get { return deploymentId_; } + set { + deploymentId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "shared_scripts" field. + public const int SharedScriptsFieldNumber = 2; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto sharedScripts_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto SharedScripts { + get { return sharedScripts_; } + set { + sharedScripts_ = value; + } + } + + /// Field number for the "external_systems" field. + public const int ExternalSystemsFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto externalSystems_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto ExternalSystems { + get { return externalSystems_; } + set { + externalSystems_ = value; + } + } + + /// Field number for the "database_connections" field. + public const int DatabaseConnectionsFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto databaseConnections_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto DatabaseConnections { + get { return databaseConnections_; } + set { + databaseConnections_ = value; + } + } + + /// Field number for the "notification_lists" field. + public const int NotificationListsFieldNumber = 5; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto notificationLists_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto NotificationLists { + get { return notificationLists_; } + set { + notificationLists_ = value; + } + } + + /// Field number for the "data_connections" field. + public const int DataConnectionsFieldNumber = 6; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto dataConnections_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto DataConnections { + get { return dataConnections_; } + set { + dataConnections_ = value; + } + } + + /// Field number for the "smtp_configurations" field. + public const int SmtpConfigurationsFieldNumber = 7; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto smtpConfigurations_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto SmtpConfigurations { + get { return smtpConfigurations_; } + set { + smtpConfigurations_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 8; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DeployArtifactsCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DeployArtifactsCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DeploymentId != other.DeploymentId) return false; + if (!object.Equals(SharedScripts, other.SharedScripts)) return false; + if (!object.Equals(ExternalSystems, other.ExternalSystems)) return false; + if (!object.Equals(DatabaseConnections, other.DatabaseConnections)) return false; + if (!object.Equals(NotificationLists, other.NotificationLists)) return false; + if (!object.Equals(DataConnections, other.DataConnections)) return false; + if (!object.Equals(SmtpConfigurations, other.SmtpConfigurations)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (DeploymentId.Length != 0) hash ^= DeploymentId.GetHashCode(); + if (sharedScripts_ != null) hash ^= SharedScripts.GetHashCode(); + if (externalSystems_ != null) hash ^= ExternalSystems.GetHashCode(); + if (databaseConnections_ != null) hash ^= DatabaseConnections.GetHashCode(); + if (notificationLists_ != null) hash ^= NotificationLists.GetHashCode(); + if (dataConnections_ != null) hash ^= DataConnections.GetHashCode(); + if (smtpConfigurations_ != null) hash ^= SmtpConfigurations.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (sharedScripts_ != null) { + output.WriteRawTag(18); + output.WriteMessage(SharedScripts); + } + if (externalSystems_ != null) { + output.WriteRawTag(26); + output.WriteMessage(ExternalSystems); + } + if (databaseConnections_ != null) { + output.WriteRawTag(34); + output.WriteMessage(DatabaseConnections); + } + if (notificationLists_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotificationLists); + } + if (dataConnections_ != null) { + output.WriteRawTag(50); + output.WriteMessage(DataConnections); + } + if (smtpConfigurations_ != null) { + output.WriteRawTag(58); + output.WriteMessage(SmtpConfigurations); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (sharedScripts_ != null) { + output.WriteRawTag(18); + output.WriteMessage(SharedScripts); + } + if (externalSystems_ != null) { + output.WriteRawTag(26); + output.WriteMessage(ExternalSystems); + } + if (databaseConnections_ != null) { + output.WriteRawTag(34); + output.WriteMessage(DatabaseConnections); + } + if (notificationLists_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotificationLists); + } + if (dataConnections_ != null) { + output.WriteRawTag(50); + output.WriteMessage(DataConnections); + } + if (smtpConfigurations_ != null) { + output.WriteRawTag(58); + output.WriteMessage(SmtpConfigurations); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (DeploymentId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeploymentId); + } + if (sharedScripts_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SharedScripts); + } + if (externalSystems_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ExternalSystems); + } + if (databaseConnections_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DatabaseConnections); + } + if (notificationLists_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NotificationLists); + } + if (dataConnections_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DataConnections); + } + if (smtpConfigurations_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SmtpConfigurations); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DeployArtifactsCommandDto other) { + if (other == null) { + return; + } + if (other.DeploymentId.Length != 0) { + DeploymentId = other.DeploymentId; + } + if (other.sharedScripts_ != null) { + if (sharedScripts_ == null) { + SharedScripts = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto(); + } + SharedScripts.MergeFrom(other.SharedScripts); + } + if (other.externalSystems_ != null) { + if (externalSystems_ == null) { + ExternalSystems = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto(); + } + ExternalSystems.MergeFrom(other.ExternalSystems); + } + if (other.databaseConnections_ != null) { + if (databaseConnections_ == null) { + DatabaseConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto(); + } + DatabaseConnections.MergeFrom(other.DatabaseConnections); + } + if (other.notificationLists_ != null) { + if (notificationLists_ == null) { + NotificationLists = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto(); + } + NotificationLists.MergeFrom(other.NotificationLists); + } + if (other.dataConnections_ != null) { + if (dataConnections_ == null) { + DataConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto(); + } + DataConnections.MergeFrom(other.DataConnections); + } + if (other.smtpConfigurations_ != null) { + if (smtpConfigurations_ == null) { + SmtpConfigurations = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto(); + } + SmtpConfigurations.MergeFrom(other.SmtpConfigurations); + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + if (sharedScripts_ == null) { + SharedScripts = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto(); + } + input.ReadMessage(SharedScripts); + break; + } + case 26: { + if (externalSystems_ == null) { + ExternalSystems = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto(); + } + input.ReadMessage(ExternalSystems); + break; + } + case 34: { + if (databaseConnections_ == null) { + DatabaseConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto(); + } + input.ReadMessage(DatabaseConnections); + break; + } + case 42: { + if (notificationLists_ == null) { + NotificationLists = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto(); + } + input.ReadMessage(NotificationLists); + break; + } + case 50: { + if (dataConnections_ == null) { + DataConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto(); + } + input.ReadMessage(DataConnections); + break; + } + case 58: { + if (smtpConfigurations_ == null) { + SmtpConfigurations = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto(); + } + input.ReadMessage(SmtpConfigurations); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + if (sharedScripts_ == null) { + SharedScripts = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SharedScriptArtifactListDto(); + } + input.ReadMessage(SharedScripts); + break; + } + case 26: { + if (externalSystems_ == null) { + ExternalSystems = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ExternalSystemArtifactListDto(); + } + input.ReadMessage(ExternalSystems); + break; + } + case 34: { + if (databaseConnections_ == null) { + DatabaseConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DatabaseConnectionArtifactListDto(); + } + input.ReadMessage(DatabaseConnections); + break; + } + case 42: { + if (notificationLists_ == null) { + NotificationLists = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.NotificationListArtifactListDto(); + } + input.ReadMessage(NotificationLists); + break; + } + case 50: { + if (dataConnections_ == null) { + DataConnections = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DataConnectionArtifactListDto(); + } + input.ReadMessage(DataConnections); + break; + } + case 58: { + if (smtpConfigurations_ == null) { + SmtpConfigurations = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SmtpConfigurationArtifactListDto(); + } + input.ReadMessage(SmtpConfigurations); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DeploymentStatusResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeploymentStatusResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[22]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStatusResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStatusResponseDto(DeploymentStatusResponseDto other) : this() { + deploymentId_ = other.deploymentId_; + instanceUniqueName_ = other.instanceUniqueName_; + status_ = other.status_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStatusResponseDto Clone() { + return new DeploymentStatusResponseDto(this); + } + + /// Field number for the "deployment_id" field. + public const int DeploymentIdFieldNumber = 1; + private string deploymentId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DeploymentId { + get { return deploymentId_; } + set { + deploymentId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "status" field. + public const int StatusFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto status_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto Status { + get { return status_; } + set { + status_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DeploymentStatusResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DeploymentStatusResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DeploymentId != other.DeploymentId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (Status != other.Status) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (DeploymentId.Length != 0) hash ^= DeploymentId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (Status != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified) hash ^= Status.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (Status != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) Status); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (Status != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) Status); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (DeploymentId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeploymentId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (Status != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Status); + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DeploymentStatusResponseDto other) { + if (other == null) { + return; + } + if (other.DeploymentId.Length != 0) { + DeploymentId = other.DeploymentId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.Status != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto.Unspecified) { + Status = other.Status; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + Status = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto) input.ReadEnum(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + Status = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusDto) input.ReadEnum(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class InstanceLifecycleResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new InstanceLifecycleResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[23]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public InstanceLifecycleResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public InstanceLifecycleResponseDto(InstanceLifecycleResponseDto other) : this() { + commandId_ = other.commandId_; + instanceUniqueName_ = other.instanceUniqueName_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public InstanceLifecycleResponseDto Clone() { + return new InstanceLifecycleResponseDto(this); + } + + /// Field number for the "command_id" field. + public const int CommandIdFieldNumber = 1; + private string commandId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CommandId { + get { return commandId_; } + set { + commandId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 3; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as InstanceLifecycleResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(InstanceLifecycleResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CommandId != other.CommandId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CommandId.Length != 0) hash ^= CommandId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CommandId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CommandId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CommandId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CommandId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(InstanceLifecycleResponseDto other) { + if (other == null) { + return; + } + if (other.CommandId.Length != 0) { + CommandId = other.CommandId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CommandId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DeploymentStateQueryResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DeploymentStateQueryResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[24]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryResponseDto(DeploymentStateQueryResponseDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + isDeployed_ = other.isDeployed_; + appliedDeploymentId_ = other.appliedDeploymentId_; + appliedRevisionHash_ = other.appliedRevisionHash_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DeploymentStateQueryResponseDto Clone() { + return new DeploymentStateQueryResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "is_deployed" field. + public const int IsDeployedFieldNumber = 3; + private bool isDeployed_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool IsDeployed { + get { return isDeployed_; } + set { + isDeployed_ = value; + } + } + + /// Field number for the "applied_deployment_id" field. + public const int AppliedDeploymentIdFieldNumber = 4; + private string appliedDeploymentId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AppliedDeploymentId { + get { return appliedDeploymentId_; } + set { + appliedDeploymentId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "applied_revision_hash" field. + public const int AppliedRevisionHashFieldNumber = 5; + private string appliedRevisionHash_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AppliedRevisionHash { + get { return appliedRevisionHash_; } + set { + appliedRevisionHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DeploymentStateQueryResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DeploymentStateQueryResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (IsDeployed != other.IsDeployed) return false; + if (AppliedDeploymentId != other.AppliedDeploymentId) return false; + if (AppliedRevisionHash != other.AppliedRevisionHash) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (IsDeployed != false) hash ^= IsDeployed.GetHashCode(); + if (AppliedDeploymentId.Length != 0) hash ^= AppliedDeploymentId.GetHashCode(); + if (AppliedRevisionHash.Length != 0) hash ^= AppliedRevisionHash.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (IsDeployed != false) { + output.WriteRawTag(24); + output.WriteBool(IsDeployed); + } + if (AppliedDeploymentId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AppliedDeploymentId); + } + if (AppliedRevisionHash.Length != 0) { + output.WriteRawTag(42); + output.WriteString(AppliedRevisionHash); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (IsDeployed != false) { + output.WriteRawTag(24); + output.WriteBool(IsDeployed); + } + if (AppliedDeploymentId.Length != 0) { + output.WriteRawTag(34); + output.WriteString(AppliedDeploymentId); + } + if (AppliedRevisionHash.Length != 0) { + output.WriteRawTag(42); + output.WriteString(AppliedRevisionHash); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (IsDeployed != false) { + size += 1 + 1; + } + if (AppliedDeploymentId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AppliedDeploymentId); + } + if (AppliedRevisionHash.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AppliedRevisionHash); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DeploymentStateQueryResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.IsDeployed != false) { + IsDeployed = other.IsDeployed; + } + if (other.AppliedDeploymentId.Length != 0) { + AppliedDeploymentId = other.AppliedDeploymentId; + } + if (other.AppliedRevisionHash.Length != 0) { + AppliedRevisionHash = other.AppliedRevisionHash; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + IsDeployed = input.ReadBool(); + break; + } + case 34: { + AppliedDeploymentId = input.ReadString(); + break; + } + case 42: { + AppliedRevisionHash = input.ReadString(); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 24: { + IsDeployed = input.ReadBool(); + break; + } + case 34: { + AppliedDeploymentId = input.ReadString(); + break; + } + case 42: { + AppliedRevisionHash = input.ReadString(); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ArtifactDeploymentResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ArtifactDeploymentResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[25]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ArtifactDeploymentResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ArtifactDeploymentResponseDto(ArtifactDeploymentResponseDto other) : this() { + deploymentId_ = other.deploymentId_; + siteId_ = other.siteId_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ArtifactDeploymentResponseDto Clone() { + return new ArtifactDeploymentResponseDto(this); + } + + /// Field number for the "deployment_id" field. + public const int DeploymentIdFieldNumber = 1; + private string deploymentId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DeploymentId { + get { return deploymentId_; } + set { + deploymentId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 3; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ArtifactDeploymentResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ArtifactDeploymentResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DeploymentId != other.DeploymentId) return false; + if (SiteId != other.SiteId) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (DeploymentId.Length != 0) hash ^= DeploymentId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (DeploymentId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(DeploymentId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (DeploymentId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeploymentId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ArtifactDeploymentResponseDto other) { + if (other == null) { + return; + } + if (other.DeploymentId.Length != 0) { + DeploymentId = other.DeploymentId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + DeploymentId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LifecycleRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LifecycleRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[26]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleRequest(LifecycleRequest other) : this() { + switch (other.CommandCase) { + case CommandOneofCase.RefreshDeployment: + RefreshDeployment = other.RefreshDeployment.Clone(); + break; + case CommandOneofCase.EnableInstance: + EnableInstance = other.EnableInstance.Clone(); + break; + case CommandOneofCase.DisableInstance: + DisableInstance = other.DisableInstance.Clone(); + break; + case CommandOneofCase.DeleteInstance: + DeleteInstance = other.DeleteInstance.Clone(); + break; + case CommandOneofCase.DeploymentStateQuery: + DeploymentStateQuery = other.DeploymentStateQuery.Clone(); + break; + case CommandOneofCase.DeployArtifacts: + DeployArtifacts = other.DeployArtifacts.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleRequest Clone() { + return new LifecycleRequest(this); + } + + /// Field number for the "refresh_deployment" field. + public const int RefreshDeploymentFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto RefreshDeployment { + get { return commandCase_ == CommandOneofCase.RefreshDeployment ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RefreshDeployment; + } + } + + /// Field number for the "enable_instance" field. + public const int EnableInstanceFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto EnableInstance { + get { return commandCase_ == CommandOneofCase.EnableInstance ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.EnableInstance; + } + } + + /// Field number for the "disable_instance" field. + public const int DisableInstanceFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto DisableInstance { + get { return commandCase_ == CommandOneofCase.DisableInstance ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DisableInstance; + } + } + + /// Field number for the "delete_instance" field. + public const int DeleteInstanceFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto DeleteInstance { + get { return commandCase_ == CommandOneofCase.DeleteInstance ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DeleteInstance; + } + } + + /// Field number for the "deployment_state_query" field. + public const int DeploymentStateQueryFieldNumber = 5; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto DeploymentStateQuery { + get { return commandCase_ == CommandOneofCase.DeploymentStateQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DeploymentStateQuery; + } + } + + /// Field number for the "deploy_artifacts" field. + public const int DeployArtifactsFieldNumber = 6; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto DeployArtifacts { + get { return commandCase_ == CommandOneofCase.DeployArtifacts ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DeployArtifacts; + } + } + + private object command_; + /// Enum of possible cases for the "command" oneof. + public enum CommandOneofCase { + None = 0, + RefreshDeployment = 1, + EnableInstance = 2, + DisableInstance = 3, + DeleteInstance = 4, + DeploymentStateQuery = 5, + DeployArtifacts = 6, + } + private CommandOneofCase commandCase_ = CommandOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CommandOneofCase CommandCase { + get { return commandCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearCommand() { + commandCase_ = CommandOneofCase.None; + command_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LifecycleRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LifecycleRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RefreshDeployment, other.RefreshDeployment)) return false; + if (!object.Equals(EnableInstance, other.EnableInstance)) return false; + if (!object.Equals(DisableInstance, other.DisableInstance)) return false; + if (!object.Equals(DeleteInstance, other.DeleteInstance)) return false; + if (!object.Equals(DeploymentStateQuery, other.DeploymentStateQuery)) return false; + if (!object.Equals(DeployArtifacts, other.DeployArtifacts)) return false; + if (CommandCase != other.CommandCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (commandCase_ == CommandOneofCase.RefreshDeployment) hash ^= RefreshDeployment.GetHashCode(); + if (commandCase_ == CommandOneofCase.EnableInstance) hash ^= EnableInstance.GetHashCode(); + if (commandCase_ == CommandOneofCase.DisableInstance) hash ^= DisableInstance.GetHashCode(); + if (commandCase_ == CommandOneofCase.DeleteInstance) hash ^= DeleteInstance.GetHashCode(); + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) hash ^= DeploymentStateQuery.GetHashCode(); + if (commandCase_ == CommandOneofCase.DeployArtifacts) hash ^= DeployArtifacts.GetHashCode(); + hash ^= (int) commandCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (commandCase_ == CommandOneofCase.RefreshDeployment) { + output.WriteRawTag(10); + output.WriteMessage(RefreshDeployment); + } + if (commandCase_ == CommandOneofCase.EnableInstance) { + output.WriteRawTag(18); + output.WriteMessage(EnableInstance); + } + if (commandCase_ == CommandOneofCase.DisableInstance) { + output.WriteRawTag(26); + output.WriteMessage(DisableInstance); + } + if (commandCase_ == CommandOneofCase.DeleteInstance) { + output.WriteRawTag(34); + output.WriteMessage(DeleteInstance); + } + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) { + output.WriteRawTag(42); + output.WriteMessage(DeploymentStateQuery); + } + if (commandCase_ == CommandOneofCase.DeployArtifacts) { + output.WriteRawTag(50); + output.WriteMessage(DeployArtifacts); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (commandCase_ == CommandOneofCase.RefreshDeployment) { + output.WriteRawTag(10); + output.WriteMessage(RefreshDeployment); + } + if (commandCase_ == CommandOneofCase.EnableInstance) { + output.WriteRawTag(18); + output.WriteMessage(EnableInstance); + } + if (commandCase_ == CommandOneofCase.DisableInstance) { + output.WriteRawTag(26); + output.WriteMessage(DisableInstance); + } + if (commandCase_ == CommandOneofCase.DeleteInstance) { + output.WriteRawTag(34); + output.WriteMessage(DeleteInstance); + } + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) { + output.WriteRawTag(42); + output.WriteMessage(DeploymentStateQuery); + } + if (commandCase_ == CommandOneofCase.DeployArtifacts) { + output.WriteRawTag(50); + output.WriteMessage(DeployArtifacts); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (commandCase_ == CommandOneofCase.RefreshDeployment) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RefreshDeployment); + } + if (commandCase_ == CommandOneofCase.EnableInstance) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EnableInstance); + } + if (commandCase_ == CommandOneofCase.DisableInstance) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DisableInstance); + } + if (commandCase_ == CommandOneofCase.DeleteInstance) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DeleteInstance); + } + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DeploymentStateQuery); + } + if (commandCase_ == CommandOneofCase.DeployArtifacts) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DeployArtifacts); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LifecycleRequest other) { + if (other == null) { + return; + } + switch (other.CommandCase) { + case CommandOneofCase.RefreshDeployment: + if (RefreshDeployment == null) { + RefreshDeployment = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto(); + } + RefreshDeployment.MergeFrom(other.RefreshDeployment); + break; + case CommandOneofCase.EnableInstance: + if (EnableInstance == null) { + EnableInstance = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto(); + } + EnableInstance.MergeFrom(other.EnableInstance); + break; + case CommandOneofCase.DisableInstance: + if (DisableInstance == null) { + DisableInstance = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto(); + } + DisableInstance.MergeFrom(other.DisableInstance); + break; + case CommandOneofCase.DeleteInstance: + if (DeleteInstance == null) { + DeleteInstance = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto(); + } + DeleteInstance.MergeFrom(other.DeleteInstance); + break; + case CommandOneofCase.DeploymentStateQuery: + if (DeploymentStateQuery == null) { + DeploymentStateQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto(); + } + DeploymentStateQuery.MergeFrom(other.DeploymentStateQuery); + break; + case CommandOneofCase.DeployArtifacts: + if (DeployArtifacts == null) { + DeployArtifacts = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto(); + } + DeployArtifacts.MergeFrom(other.DeployArtifacts); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto(); + if (commandCase_ == CommandOneofCase.RefreshDeployment) { + subBuilder.MergeFrom(RefreshDeployment); + } + input.ReadMessage(subBuilder); + RefreshDeployment = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.EnableInstance) { + subBuilder.MergeFrom(EnableInstance); + } + input.ReadMessage(subBuilder); + EnableInstance = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.DisableInstance) { + subBuilder.MergeFrom(DisableInstance); + } + input.ReadMessage(subBuilder); + DisableInstance = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.DeleteInstance) { + subBuilder.MergeFrom(DeleteInstance); + } + input.ReadMessage(subBuilder); + DeleteInstance = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto(); + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) { + subBuilder.MergeFrom(DeploymentStateQuery); + } + input.ReadMessage(subBuilder); + DeploymentStateQuery = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto(); + if (commandCase_ == CommandOneofCase.DeployArtifacts) { + subBuilder.MergeFrom(DeployArtifacts); + } + input.ReadMessage(subBuilder); + DeployArtifacts = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RefreshDeploymentCommandDto(); + if (commandCase_ == CommandOneofCase.RefreshDeployment) { + subBuilder.MergeFrom(RefreshDeployment); + } + input.ReadMessage(subBuilder); + RefreshDeployment = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EnableInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.EnableInstance) { + subBuilder.MergeFrom(EnableInstance); + } + input.ReadMessage(subBuilder); + EnableInstance = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DisableInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.DisableInstance) { + subBuilder.MergeFrom(DisableInstance); + } + input.ReadMessage(subBuilder); + DisableInstance = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeleteInstanceCommandDto(); + if (commandCase_ == CommandOneofCase.DeleteInstance) { + subBuilder.MergeFrom(DeleteInstance); + } + input.ReadMessage(subBuilder); + DeleteInstance = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryRequestDto(); + if (commandCase_ == CommandOneofCase.DeploymentStateQuery) { + subBuilder.MergeFrom(DeploymentStateQuery); + } + input.ReadMessage(subBuilder); + DeploymentStateQuery = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeployArtifactsCommandDto(); + if (commandCase_ == CommandOneofCase.DeployArtifacts) { + subBuilder.MergeFrom(DeployArtifacts); + } + input.ReadMessage(subBuilder); + DeployArtifacts = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class LifecycleReply : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LifecycleReply()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[27]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleReply() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleReply(LifecycleReply other) : this() { + switch (other.ReplyCase) { + case ReplyOneofCase.DeploymentStatus: + DeploymentStatus = other.DeploymentStatus.Clone(); + break; + case ReplyOneofCase.InstanceLifecycle: + InstanceLifecycle = other.InstanceLifecycle.Clone(); + break; + case ReplyOneofCase.DeploymentStateQuery: + DeploymentStateQuery = other.DeploymentStateQuery.Clone(); + break; + case ReplyOneofCase.ArtifactDeployment: + ArtifactDeployment = other.ArtifactDeployment.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public LifecycleReply Clone() { + return new LifecycleReply(this); + } + + /// Field number for the "deployment_status" field. + public const int DeploymentStatusFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto DeploymentStatus { + get { return replyCase_ == ReplyOneofCase.DeploymentStatus ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.DeploymentStatus; + } + } + + /// Field number for the "instance_lifecycle" field. + public const int InstanceLifecycleFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto InstanceLifecycle { + get { return replyCase_ == ReplyOneofCase.InstanceLifecycle ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.InstanceLifecycle; + } + } + + /// Field number for the "deployment_state_query" field. + public const int DeploymentStateQueryFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto DeploymentStateQuery { + get { return replyCase_ == ReplyOneofCase.DeploymentStateQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.DeploymentStateQuery; + } + } + + /// Field number for the "artifact_deployment" field. + public const int ArtifactDeploymentFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto ArtifactDeployment { + get { return replyCase_ == ReplyOneofCase.ArtifactDeployment ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ArtifactDeployment; + } + } + + private object reply_; + /// Enum of possible cases for the "reply" oneof. + public enum ReplyOneofCase { + None = 0, + DeploymentStatus = 1, + InstanceLifecycle = 2, + DeploymentStateQuery = 3, + ArtifactDeployment = 4, + } + private ReplyOneofCase replyCase_ = ReplyOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReplyOneofCase ReplyCase { + get { return replyCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReply() { + replyCase_ = ReplyOneofCase.None; + reply_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as LifecycleReply); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(LifecycleReply other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(DeploymentStatus, other.DeploymentStatus)) return false; + if (!object.Equals(InstanceLifecycle, other.InstanceLifecycle)) return false; + if (!object.Equals(DeploymentStateQuery, other.DeploymentStateQuery)) return false; + if (!object.Equals(ArtifactDeployment, other.ArtifactDeployment)) return false; + if (ReplyCase != other.ReplyCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (replyCase_ == ReplyOneofCase.DeploymentStatus) hash ^= DeploymentStatus.GetHashCode(); + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) hash ^= InstanceLifecycle.GetHashCode(); + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) hash ^= DeploymentStateQuery.GetHashCode(); + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) hash ^= ArtifactDeployment.GetHashCode(); + hash ^= (int) replyCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (replyCase_ == ReplyOneofCase.DeploymentStatus) { + output.WriteRawTag(10); + output.WriteMessage(DeploymentStatus); + } + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) { + output.WriteRawTag(18); + output.WriteMessage(InstanceLifecycle); + } + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) { + output.WriteRawTag(26); + output.WriteMessage(DeploymentStateQuery); + } + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) { + output.WriteRawTag(34); + output.WriteMessage(ArtifactDeployment); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (replyCase_ == ReplyOneofCase.DeploymentStatus) { + output.WriteRawTag(10); + output.WriteMessage(DeploymentStatus); + } + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) { + output.WriteRawTag(18); + output.WriteMessage(InstanceLifecycle); + } + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) { + output.WriteRawTag(26); + output.WriteMessage(DeploymentStateQuery); + } + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) { + output.WriteRawTag(34); + output.WriteMessage(ArtifactDeployment); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (replyCase_ == ReplyOneofCase.DeploymentStatus) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DeploymentStatus); + } + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(InstanceLifecycle); + } + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DeploymentStateQuery); + } + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ArtifactDeployment); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(LifecycleReply other) { + if (other == null) { + return; + } + switch (other.ReplyCase) { + case ReplyOneofCase.DeploymentStatus: + if (DeploymentStatus == null) { + DeploymentStatus = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto(); + } + DeploymentStatus.MergeFrom(other.DeploymentStatus); + break; + case ReplyOneofCase.InstanceLifecycle: + if (InstanceLifecycle == null) { + InstanceLifecycle = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto(); + } + InstanceLifecycle.MergeFrom(other.InstanceLifecycle); + break; + case ReplyOneofCase.DeploymentStateQuery: + if (DeploymentStateQuery == null) { + DeploymentStateQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto(); + } + DeploymentStateQuery.MergeFrom(other.DeploymentStateQuery); + break; + case ReplyOneofCase.ArtifactDeployment: + if (ArtifactDeployment == null) { + ArtifactDeployment = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto(); + } + ArtifactDeployment.MergeFrom(other.ArtifactDeployment); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto(); + if (replyCase_ == ReplyOneofCase.DeploymentStatus) { + subBuilder.MergeFrom(DeploymentStatus); + } + input.ReadMessage(subBuilder); + DeploymentStatus = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto(); + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) { + subBuilder.MergeFrom(InstanceLifecycle); + } + input.ReadMessage(subBuilder); + InstanceLifecycle = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) { + subBuilder.MergeFrom(DeploymentStateQuery); + } + input.ReadMessage(subBuilder); + DeploymentStateQuery = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto(); + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) { + subBuilder.MergeFrom(ArtifactDeployment); + } + input.ReadMessage(subBuilder); + ArtifactDeployment = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStatusResponseDto(); + if (replyCase_ == ReplyOneofCase.DeploymentStatus) { + subBuilder.MergeFrom(DeploymentStatus); + } + input.ReadMessage(subBuilder); + DeploymentStatus = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.InstanceLifecycleResponseDto(); + if (replyCase_ == ReplyOneofCase.InstanceLifecycle) { + subBuilder.MergeFrom(InstanceLifecycle); + } + input.ReadMessage(subBuilder); + InstanceLifecycle = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DeploymentStateQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.DeploymentStateQuery) { + subBuilder.MergeFrom(DeploymentStateQuery); + } + input.ReadMessage(subBuilder); + DeploymentStateQuery = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ArtifactDeploymentResponseDto(); + if (replyCase_ == ReplyOneofCase.ArtifactDeployment) { + subBuilder.MergeFrom(ArtifactDeployment); + } + input.ReadMessage(subBuilder); + ArtifactDeployment = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BrowseNodeCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BrowseNodeCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[28]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeCommandDto(BrowseNodeCommandDto other) : this() { + connectionName_ = other.connectionName_; + parentNodeId_ = other.parentNodeId_; + continuationToken_ = other.continuationToken_; + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeCommandDto Clone() { + return new BrowseNodeCommandDto(this); + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 1; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "parent_node_id" field. + public const int ParentNodeIdFieldNumber = 2; + private string parentNodeId_ = ""; + /// + /// empty string represents null (browse root) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParentNodeId { + get { return parentNodeId_; } + set { + parentNodeId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "continuation_token" field. + public const int ContinuationTokenFieldNumber = 3; + private string continuationToken_ = ""; + /// + /// empty string represents null (first page) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ContinuationToken { + get { return continuationToken_; } + set { + continuationToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 4; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BrowseNodeCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BrowseNodeCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConnectionName != other.ConnectionName) return false; + if (ParentNodeId != other.ParentNodeId) return false; + if (ContinuationToken != other.ContinuationToken) return false; + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + if (ParentNodeId.Length != 0) hash ^= ParentNodeId.GetHashCode(); + if (ContinuationToken.Length != 0) hash ^= ContinuationToken.GetHashCode(); + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (ParentNodeId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ParentNodeId); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ContinuationToken); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (ParentNodeId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ParentNodeId); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ContinuationToken); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + if (ParentNodeId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParentNodeId); + } + if (ContinuationToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ContinuationToken); + } + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BrowseNodeCommandDto other) { + if (other == null) { + return; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + if (other.ParentNodeId.Length != 0) { + ParentNodeId = other.ParentNodeId; + } + if (other.ContinuationToken.Length != 0) { + ContinuationToken = other.ContinuationToken; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + ParentNodeId = input.ReadString(); + break; + } + case 26: { + ContinuationToken = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + ParentNodeId = input.ReadString(); + break; + } + case 26: { + ContinuationToken = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BrowseNodeDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BrowseNodeDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[29]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeDto(BrowseNodeDto other) : this() { + nodeId_ = other.nodeId_; + displayName_ = other.displayName_; + nodeClass_ = other.nodeClass_; + hasChildren_ = other.hasChildren_; + dataType_ = other.dataType_; + ValueRank = other.ValueRank; + Writable = other.Writable; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeDto Clone() { + return new BrowseNodeDto(this); + } + + /// Field number for the "node_id" field. + public const int NodeIdFieldNumber = 1; + private string nodeId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NodeId { + get { return nodeId_; } + set { + nodeId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "display_name" field. + public const int DisplayNameFieldNumber = 2; + private string displayName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DisplayName { + get { return displayName_; } + set { + displayName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "node_class" field. + public const int NodeClassFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto nodeClass_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto NodeClass { + get { return nodeClass_; } + set { + nodeClass_ = value; + } + } + + /// Field number for the "has_children" field. + public const int HasChildrenFieldNumber = 4; + private bool hasChildren_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasChildren { + get { return hasChildren_; } + set { + hasChildren_ = value; + } + } + + /// Field number for the "data_type" field. + public const int DataTypeFieldNumber = 5; + private string dataType_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DataType { + get { return dataType_; } + set { + dataType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "value_rank" field. + public const int ValueRankFieldNumber = 6; + private static readonly pb::FieldCodec _single_valueRank_codec = pb::FieldCodec.ForStructWrapper(50); + private int? valueRank_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int? ValueRank { + get { return valueRank_; } + set { + valueRank_ = value; + } + } + + + /// Field number for the "writable" field. + public const int WritableFieldNumber = 7; + private static readonly pb::FieldCodec _single_writable_codec = pb::FieldCodec.ForStructWrapper(58); + private bool? writable_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool? Writable { + get { return writable_; } + set { + writable_ = value; + } + } + + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BrowseNodeDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BrowseNodeDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (NodeId != other.NodeId) return false; + if (DisplayName != other.DisplayName) return false; + if (NodeClass != other.NodeClass) return false; + if (HasChildren != other.HasChildren) return false; + if (DataType != other.DataType) return false; + if (ValueRank != other.ValueRank) return false; + if (Writable != other.Writable) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (NodeId.Length != 0) hash ^= NodeId.GetHashCode(); + if (DisplayName.Length != 0) hash ^= DisplayName.GetHashCode(); + if (NodeClass != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified) hash ^= NodeClass.GetHashCode(); + if (HasChildren != false) hash ^= HasChildren.GetHashCode(); + if (DataType.Length != 0) hash ^= DataType.GetHashCode(); + if (valueRank_ != null) hash ^= ValueRank.GetHashCode(); + if (writable_ != null) hash ^= Writable.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (NodeId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(NodeId); + } + if (DisplayName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DisplayName); + } + if (NodeClass != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) NodeClass); + } + if (HasChildren != false) { + output.WriteRawTag(32); + output.WriteBool(HasChildren); + } + if (DataType.Length != 0) { + output.WriteRawTag(42); + output.WriteString(DataType); + } + if (valueRank_ != null) { + _single_valueRank_codec.WriteTagAndValue(output, ValueRank); + } + if (writable_ != null) { + _single_writable_codec.WriteTagAndValue(output, Writable); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (NodeId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(NodeId); + } + if (DisplayName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DisplayName); + } + if (NodeClass != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) NodeClass); + } + if (HasChildren != false) { + output.WriteRawTag(32); + output.WriteBool(HasChildren); + } + if (DataType.Length != 0) { + output.WriteRawTag(42); + output.WriteString(DataType); + } + if (valueRank_ != null) { + _single_valueRank_codec.WriteTagAndValue(ref output, ValueRank); + } + if (writable_ != null) { + _single_writable_codec.WriteTagAndValue(ref output, Writable); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (NodeId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NodeId); + } + if (DisplayName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DisplayName); + } + if (NodeClass != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) NodeClass); + } + if (HasChildren != false) { + size += 1 + 1; + } + if (DataType.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DataType); + } + if (valueRank_ != null) { + size += _single_valueRank_codec.CalculateSizeWithTag(ValueRank); + } + if (writable_ != null) { + size += _single_writable_codec.CalculateSizeWithTag(Writable); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BrowseNodeDto other) { + if (other == null) { + return; + } + if (other.NodeId.Length != 0) { + NodeId = other.NodeId; + } + if (other.DisplayName.Length != 0) { + DisplayName = other.DisplayName; + } + if (other.NodeClass != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto.Unspecified) { + NodeClass = other.NodeClass; + } + if (other.HasChildren != false) { + HasChildren = other.HasChildren; + } + if (other.DataType.Length != 0) { + DataType = other.DataType; + } + if (other.valueRank_ != null) { + if (valueRank_ == null || other.ValueRank != 0) { + ValueRank = other.ValueRank; + } + } + if (other.writable_ != null) { + if (writable_ == null || other.Writable != false) { + Writable = other.Writable; + } + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + NodeId = input.ReadString(); + break; + } + case 18: { + DisplayName = input.ReadString(); + break; + } + case 24: { + NodeClass = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto) input.ReadEnum(); + break; + } + case 32: { + HasChildren = input.ReadBool(); + break; + } + case 42: { + DataType = input.ReadString(); + break; + } + case 50: { + int? value = _single_valueRank_codec.Read(input); + if (valueRank_ == null || value != 0) { + ValueRank = value; + } + break; + } + case 58: { + bool? value = _single_writable_codec.Read(input); + if (writable_ == null || value != false) { + Writable = value; + } + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + NodeId = input.ReadString(); + break; + } + case 18: { + DisplayName = input.ReadString(); + break; + } + case 24: { + NodeClass = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeClassDto) input.ReadEnum(); + break; + } + case 32: { + HasChildren = input.ReadBool(); + break; + } + case 42: { + DataType = input.ReadString(); + break; + } + case 50: { + int? value = _single_valueRank_codec.Read(ref input); + if (valueRank_ == null || value != 0) { + ValueRank = value; + } + break; + } + case 58: { + bool? value = _single_writable_codec.Read(ref input); + if (writable_ == null || value != false) { + Writable = value; + } + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BrowseFailureDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BrowseFailureDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[30]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseFailureDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseFailureDto(BrowseFailureDto other) : this() { + kind_ = other.kind_; + message_ = other.message_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseFailureDto Clone() { + return new BrowseFailureDto(this); + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 1; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto kind_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto Kind { + get { return kind_; } + set { + kind_ = value; + } + } + + /// Field number for the "message" field. + public const int MessageFieldNumber = 2; + private string message_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Message { + get { return message_; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BrowseFailureDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BrowseFailureDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Kind != other.Kind) return false; + if (Message != other.Message) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified) hash ^= Kind.GetHashCode(); + if (Message.Length != 0) hash ^= Message.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (Message.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Message); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (Message.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Message); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); + } + if (Message.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Message); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BrowseFailureDto other) { + if (other == null) { + return; + } + if (other.Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto.Unspecified) { + Kind = other.Kind; + } + if (other.Message.Length != 0) { + Message = other.Message; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto) input.ReadEnum(); + break; + } + case 18: { + Message = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureKindDto) input.ReadEnum(); + break; + } + case 18: { + Message = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class BrowseNodeResultDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new BrowseNodeResultDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[31]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeResultDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeResultDto(BrowseNodeResultDto other) : this() { + children_ = other.children_.Clone(); + truncated_ = other.truncated_; + failure_ = other.failure_ != null ? other.failure_.Clone() : null; + continuationToken_ = other.continuationToken_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public BrowseNodeResultDto Clone() { + return new BrowseNodeResultDto(this); + } + + /// Field number for the "children" field. + public const int ChildrenFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_children_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto.Parser); + private readonly pbc::RepeatedField children_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Children { + get { return children_; } + } + + /// Field number for the "truncated" field. + public const int TruncatedFieldNumber = 2; + private bool truncated_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Truncated { + get { return truncated_; } + set { + truncated_ = value; + } + } + + /// Field number for the "failure" field. + public const int FailureFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto failure_; + /// + /// absent => null (success) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto Failure { + get { return failure_; } + set { + failure_ = value; + } + } + + /// Field number for the "continuation_token" field. + public const int ContinuationTokenFieldNumber = 4; + private string continuationToken_ = ""; + /// + /// empty string represents null (final page) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ContinuationToken { + get { return continuationToken_; } + set { + continuationToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as BrowseNodeResultDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(BrowseNodeResultDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!children_.Equals(other.children_)) return false; + if (Truncated != other.Truncated) return false; + if (!object.Equals(Failure, other.Failure)) return false; + if (ContinuationToken != other.ContinuationToken) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= children_.GetHashCode(); + if (Truncated != false) hash ^= Truncated.GetHashCode(); + if (failure_ != null) hash ^= Failure.GetHashCode(); + if (ContinuationToken.Length != 0) hash ^= ContinuationToken.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + children_.WriteTo(output, _repeated_children_codec); + if (Truncated != false) { + output.WriteRawTag(16); + output.WriteBool(Truncated); + } + if (failure_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Failure); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ContinuationToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + children_.WriteTo(ref output, _repeated_children_codec); + if (Truncated != false) { + output.WriteRawTag(16); + output.WriteBool(Truncated); + } + if (failure_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Failure); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ContinuationToken); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += children_.CalculateSize(_repeated_children_codec); + if (Truncated != false) { + size += 1 + 1; + } + if (failure_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Failure); + } + if (ContinuationToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ContinuationToken); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(BrowseNodeResultDto other) { + if (other == null) { + return; + } + children_.Add(other.children_); + if (other.Truncated != false) { + Truncated = other.Truncated; + } + if (other.failure_ != null) { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + Failure.MergeFrom(other.Failure); + } + if (other.ContinuationToken.Length != 0) { + ContinuationToken = other.ContinuationToken; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + children_.AddEntriesFrom(input, _repeated_children_codec); + break; + } + case 16: { + Truncated = input.ReadBool(); + break; + } + case 26: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + input.ReadMessage(Failure); + break; + } + case 34: { + ContinuationToken = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + children_.AddEntriesFrom(ref input, _repeated_children_codec); + break; + } + case 16: { + Truncated = input.ReadBool(); + break; + } + case 26: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + input.ReadMessage(Failure); + break; + } + case 34: { + ContinuationToken = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SearchAddressSpaceCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SearchAddressSpaceCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[32]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceCommandDto(SearchAddressSpaceCommandDto other) : this() { + connectionName_ = other.connectionName_; + query_ = other.query_; + maxDepth_ = other.maxDepth_; + maxResults_ = other.maxResults_; + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceCommandDto Clone() { + return new SearchAddressSpaceCommandDto(this); + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 1; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "query" field. + public const int QueryFieldNumber = 2; + private string query_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Query { + get { return query_; } + set { + query_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "max_depth" field. + public const int MaxDepthFieldNumber = 3; + private int maxDepth_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int MaxDepth { + get { return maxDepth_; } + set { + maxDepth_ = value; + } + } + + /// Field number for the "max_results" field. + public const int MaxResultsFieldNumber = 4; + private int maxResults_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int MaxResults { + get { return maxResults_; } + set { + maxResults_ = value; + } + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 5; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SearchAddressSpaceCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SearchAddressSpaceCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConnectionName != other.ConnectionName) return false; + if (Query != other.Query) return false; + if (MaxDepth != other.MaxDepth) return false; + if (MaxResults != other.MaxResults) return false; + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + if (Query.Length != 0) hash ^= Query.GetHashCode(); + if (MaxDepth != 0) hash ^= MaxDepth.GetHashCode(); + if (MaxResults != 0) hash ^= MaxResults.GetHashCode(); + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (Query.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Query); + } + if (MaxDepth != 0) { + output.WriteRawTag(24); + output.WriteInt32(MaxDepth); + } + if (MaxResults != 0) { + output.WriteRawTag(32); + output.WriteInt32(MaxResults); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(42); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (Query.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Query); + } + if (MaxDepth != 0) { + output.WriteRawTag(24); + output.WriteInt32(MaxDepth); + } + if (MaxResults != 0) { + output.WriteRawTag(32); + output.WriteInt32(MaxResults); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(42); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + if (Query.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Query); + } + if (MaxDepth != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxDepth); + } + if (MaxResults != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxResults); + } + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SearchAddressSpaceCommandDto other) { + if (other == null) { + return; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + if (other.Query.Length != 0) { + Query = other.Query; + } + if (other.MaxDepth != 0) { + MaxDepth = other.MaxDepth; + } + if (other.MaxResults != 0) { + MaxResults = other.MaxResults; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + Query = input.ReadString(); + break; + } + case 24: { + MaxDepth = input.ReadInt32(); + break; + } + case 32: { + MaxResults = input.ReadInt32(); + break; + } + case 42: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + Query = input.ReadString(); + break; + } + case 24: { + MaxDepth = input.ReadInt32(); + break; + } + case 32: { + MaxResults = input.ReadInt32(); + break; + } + case 42: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AddressSpaceMatchDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AddressSpaceMatchDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[33]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AddressSpaceMatchDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AddressSpaceMatchDto(AddressSpaceMatchDto other) : this() { + node_ = other.node_ != null ? other.node_.Clone() : null; + path_ = other.path_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AddressSpaceMatchDto Clone() { + return new AddressSpaceMatchDto(this); + } + + /// Field number for the "node" field. + public const int NodeFieldNumber = 1; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto node_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto Node { + get { return node_; } + set { + node_ = value; + } + } + + /// Field number for the "path" field. + public const int PathFieldNumber = 2; + private string path_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Path { + get { return path_; } + set { + path_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AddressSpaceMatchDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AddressSpaceMatchDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Node, other.Node)) return false; + if (Path != other.Path) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (node_ != null) hash ^= Node.GetHashCode(); + if (Path.Length != 0) hash ^= Path.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (node_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Node); + } + if (Path.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Path); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (node_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Node); + } + if (Path.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Path); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (node_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Node); + } + if (Path.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Path); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AddressSpaceMatchDto other) { + if (other == null) { + return; + } + if (other.node_ != null) { + if (node_ == null) { + Node = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto(); + } + Node.MergeFrom(other.Node); + } + if (other.Path.Length != 0) { + Path = other.Path; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (node_ == null) { + Node = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto(); + } + input.ReadMessage(Node); + break; + } + case 18: { + Path = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (node_ == null) { + Node = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeDto(); + } + input.ReadMessage(Node); + break; + } + case 18: { + Path = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SearchAddressSpaceResultDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SearchAddressSpaceResultDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[34]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceResultDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceResultDto(SearchAddressSpaceResultDto other) : this() { + matches_ = other.matches_.Clone(); + capReached_ = other.capReached_; + failure_ = other.failure_ != null ? other.failure_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SearchAddressSpaceResultDto Clone() { + return new SearchAddressSpaceResultDto(this); + } + + /// Field number for the "matches" field. + public const int MatchesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_matches_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AddressSpaceMatchDto.Parser); + private readonly pbc::RepeatedField matches_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Matches { + get { return matches_; } + } + + /// Field number for the "cap_reached" field. + public const int CapReachedFieldNumber = 2; + private bool capReached_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool CapReached { + get { return capReached_; } + set { + capReached_ = value; + } + } + + /// Field number for the "failure" field. + public const int FailureFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto failure_; + /// + /// absent => null (success) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto Failure { + get { return failure_; } + set { + failure_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SearchAddressSpaceResultDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SearchAddressSpaceResultDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!matches_.Equals(other.matches_)) return false; + if (CapReached != other.CapReached) return false; + if (!object.Equals(Failure, other.Failure)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= matches_.GetHashCode(); + if (CapReached != false) hash ^= CapReached.GetHashCode(); + if (failure_ != null) hash ^= Failure.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + matches_.WriteTo(output, _repeated_matches_codec); + if (CapReached != false) { + output.WriteRawTag(16); + output.WriteBool(CapReached); + } + if (failure_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Failure); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + matches_.WriteTo(ref output, _repeated_matches_codec); + if (CapReached != false) { + output.WriteRawTag(16); + output.WriteBool(CapReached); + } + if (failure_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Failure); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += matches_.CalculateSize(_repeated_matches_codec); + if (CapReached != false) { + size += 1 + 1; + } + if (failure_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Failure); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SearchAddressSpaceResultDto other) { + if (other == null) { + return; + } + matches_.Add(other.matches_); + if (other.CapReached != false) { + CapReached = other.CapReached; + } + if (other.failure_ != null) { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + Failure.MergeFrom(other.Failure); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + matches_.AddEntriesFrom(input, _repeated_matches_codec); + break; + } + case 16: { + CapReached = input.ReadBool(); + break; + } + case 26: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + input.ReadMessage(Failure); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + matches_.AddEntriesFrom(ref input, _repeated_matches_codec); + break; + } + case 16: { + CapReached = input.ReadBool(); + break; + } + case 26: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseFailureDto(); + } + input.ReadMessage(Failure); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadTagValuesCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadTagValuesCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[35]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesCommandDto(ReadTagValuesCommandDto other) : this() { + connectionName_ = other.connectionName_; + tagPaths_ = other.tagPaths_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesCommandDto Clone() { + return new ReadTagValuesCommandDto(this); + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 1; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tag_paths" field. + public const int TagPathsFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_tagPaths_codec + = pb::FieldCodec.ForString(18); + private readonly pbc::RepeatedField tagPaths_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField TagPaths { + get { return tagPaths_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadTagValuesCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadTagValuesCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConnectionName != other.ConnectionName) return false; + if(!tagPaths_.Equals(other.tagPaths_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + hash ^= tagPaths_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + tagPaths_.WriteTo(output, _repeated_tagPaths_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + tagPaths_.WriteTo(ref output, _repeated_tagPaths_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + size += tagPaths_.CalculateSize(_repeated_tagPaths_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadTagValuesCommandDto other) { + if (other == null) { + return; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + tagPaths_.Add(other.tagPaths_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + tagPaths_.AddEntriesFrom(input, _repeated_tagPaths_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + tagPaths_.AddEntriesFrom(ref input, _repeated_tagPaths_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TagReadOutcomeDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TagReadOutcomeDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[36]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TagReadOutcomeDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TagReadOutcomeDto(TagReadOutcomeDto other) : this() { + tagPath_ = other.tagPath_; + success_ = other.success_; + value_ = other.value_ != null ? other.value_.Clone() : null; + quality_ = other.quality_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + errorMessage_ = other.errorMessage_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TagReadOutcomeDto Clone() { + return new TagReadOutcomeDto(this); + } + + /// Field number for the "tag_path" field. + public const int TagPathFieldNumber = 1; + private string tagPath_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TagPath { + get { return tagPath_; } + set { + tagPath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue value_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue Value { + get { return value_; } + set { + value_ = value; + } + } + + /// Field number for the "quality" field. + public const int QualityFieldNumber = 4; + private string quality_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Quality { + get { return quality_; } + set { + quality_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 6; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TagReadOutcomeDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TagReadOutcomeDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TagPath != other.TagPath) return false; + if (Success != other.Success) return false; + if (!object.Equals(Value, other.Value)) return false; + if (Quality != other.Quality) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (ErrorMessage != other.ErrorMessage) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (TagPath.Length != 0) hash ^= TagPath.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + if (Quality.Length != 0) hash ^= Quality.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (TagPath.Length != 0) { + output.WriteRawTag(10); + output.WriteString(TagPath); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (value_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Quality); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (TagPath.Length != 0) { + output.WriteRawTag(10); + output.WriteString(TagPath); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (value_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Quality); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (TagPath.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TagPath); + } + if (Success != false) { + size += 1 + 1; + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + if (Quality.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Quality); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TagReadOutcomeDto other) { + if (other == null) { + return; + } + if (other.TagPath.Length != 0) { + TagPath = other.TagPath; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.value_ != null) { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + Value.MergeFrom(other.Value); + } + if (other.Quality.Length != 0) { + Quality = other.Quality; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + TagPath = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 34: { + Quality = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + ErrorMessage = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + TagPath = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 34: { + Quality = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + ErrorMessage = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadTagValuesFailureDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadTagValuesFailureDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[37]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesFailureDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesFailureDto(ReadTagValuesFailureDto other) : this() { + kind_ = other.kind_; + message_ = other.message_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesFailureDto Clone() { + return new ReadTagValuesFailureDto(this); + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 1; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto kind_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto Kind { + get { return kind_; } + set { + kind_ = value; + } + } + + /// Field number for the "message" field. + public const int MessageFieldNumber = 2; + private string message_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Message { + get { return message_; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadTagValuesFailureDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadTagValuesFailureDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Kind != other.Kind) return false; + if (Message != other.Message) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified) hash ^= Kind.GetHashCode(); + if (Message.Length != 0) hash ^= Message.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (Message.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Message); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (Message.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Message); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); + } + if (Message.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Message); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadTagValuesFailureDto other) { + if (other == null) { + return; + } + if (other.Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto.Unspecified) { + Kind = other.Kind; + } + if (other.Message.Length != 0) { + Message = other.Message; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto) input.ReadEnum(); + break; + } + case 18: { + Message = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureKindDto) input.ReadEnum(); + break; + } + case 18: { + Message = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ReadTagValuesResultDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ReadTagValuesResultDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[38]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesResultDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesResultDto(ReadTagValuesResultDto other) : this() { + outcomes_ = other.outcomes_.Clone(); + failure_ = other.failure_ != null ? other.failure_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReadTagValuesResultDto Clone() { + return new ReadTagValuesResultDto(this); + } + + /// Field number for the "outcomes" field. + public const int OutcomesFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_outcomes_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TagReadOutcomeDto.Parser); + private readonly pbc::RepeatedField outcomes_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Outcomes { + get { return outcomes_; } + } + + /// Field number for the "failure" field. + public const int FailureFieldNumber = 2; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto failure_; + /// + /// absent => null (success) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto Failure { + get { return failure_; } + set { + failure_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ReadTagValuesResultDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ReadTagValuesResultDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!outcomes_.Equals(other.outcomes_)) return false; + if (!object.Equals(Failure, other.Failure)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= outcomes_.GetHashCode(); + if (failure_ != null) hash ^= Failure.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + outcomes_.WriteTo(output, _repeated_outcomes_codec); + if (failure_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Failure); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + outcomes_.WriteTo(ref output, _repeated_outcomes_codec); + if (failure_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Failure); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += outcomes_.CalculateSize(_repeated_outcomes_codec); + if (failure_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Failure); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ReadTagValuesResultDto other) { + if (other == null) { + return; + } + outcomes_.Add(other.outcomes_); + if (other.failure_ != null) { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto(); + } + Failure.MergeFrom(other.Failure); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + outcomes_.AddEntriesFrom(input, _repeated_outcomes_codec); + break; + } + case 18: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto(); + } + input.ReadMessage(Failure); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + outcomes_.AddEntriesFrom(ref input, _repeated_outcomes_codec); + break; + } + case 18: { + if (failure_ == null) { + Failure = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesFailureDto(); + } + input.ReadMessage(Failure); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class VerifyEndpointCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new VerifyEndpointCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[39]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointCommandDto(VerifyEndpointCommandDto other) : this() { + connectionName_ = other.connectionName_; + protocol_ = other.protocol_; + configJson_ = other.configJson_; + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointCommandDto Clone() { + return new VerifyEndpointCommandDto(this); + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 1; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "protocol" field. + public const int ProtocolFieldNumber = 2; + private string protocol_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Protocol { + get { return protocol_; } + set { + protocol_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "config_json" field. + public const int ConfigJsonFieldNumber = 3; + private string configJson_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConfigJson { + get { return configJson_; } + set { + configJson_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 4; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as VerifyEndpointCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(VerifyEndpointCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConnectionName != other.ConnectionName) return false; + if (Protocol != other.Protocol) return false; + if (ConfigJson != other.ConfigJson) return false; + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + if (Protocol.Length != 0) hash ^= Protocol.GetHashCode(); + if (ConfigJson.Length != 0) hash ^= ConfigJson.GetHashCode(); + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (Protocol.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Protocol); + } + if (ConfigJson.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ConfigJson); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (Protocol.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Protocol); + } + if (ConfigJson.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ConfigJson); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + if (Protocol.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Protocol); + } + if (ConfigJson.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConfigJson); + } + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(VerifyEndpointCommandDto other) { + if (other == null) { + return; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + if (other.Protocol.Length != 0) { + Protocol = other.Protocol; + } + if (other.ConfigJson.Length != 0) { + ConfigJson = other.ConfigJson; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + Protocol = input.ReadString(); + break; + } + case 26: { + ConfigJson = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + Protocol = input.ReadString(); + break; + } + case 26: { + ConfigJson = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ServerCertInfoDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ServerCertInfoDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[40]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ServerCertInfoDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ServerCertInfoDto(ServerCertInfoDto other) : this() { + thumbprint_ = other.thumbprint_; + subject_ = other.subject_; + issuer_ = other.issuer_; + notBeforeUtc_ = other.notBeforeUtc_ != null ? other.notBeforeUtc_.Clone() : null; + notAfterUtc_ = other.notAfterUtc_ != null ? other.notAfterUtc_.Clone() : null; + derBase64_ = other.derBase64_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ServerCertInfoDto Clone() { + return new ServerCertInfoDto(this); + } + + /// Field number for the "thumbprint" field. + public const int ThumbprintFieldNumber = 1; + private string thumbprint_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Thumbprint { + get { return thumbprint_; } + set { + thumbprint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "subject" field. + public const int SubjectFieldNumber = 2; + private string subject_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Subject { + get { return subject_; } + set { + subject_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "issuer" field. + public const int IssuerFieldNumber = 3; + private string issuer_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Issuer { + get { return issuer_; } + set { + issuer_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "not_before_utc" field. + public const int NotBeforeUtcFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp notBeforeUtc_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp NotBeforeUtc { + get { return notBeforeUtc_; } + set { + notBeforeUtc_ = value; + } + } + + /// Field number for the "not_after_utc" field. + public const int NotAfterUtcFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp notAfterUtc_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp NotAfterUtc { + get { return notAfterUtc_; } + set { + notAfterUtc_ = value; + } + } + + /// Field number for the "der_base64" field. + public const int DerBase64FieldNumber = 6; + private string derBase64_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DerBase64 { + get { return derBase64_; } + set { + derBase64_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ServerCertInfoDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ServerCertInfoDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Thumbprint != other.Thumbprint) return false; + if (Subject != other.Subject) return false; + if (Issuer != other.Issuer) return false; + if (!object.Equals(NotBeforeUtc, other.NotBeforeUtc)) return false; + if (!object.Equals(NotAfterUtc, other.NotAfterUtc)) return false; + if (DerBase64 != other.DerBase64) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Thumbprint.Length != 0) hash ^= Thumbprint.GetHashCode(); + if (Subject.Length != 0) hash ^= Subject.GetHashCode(); + if (Issuer.Length != 0) hash ^= Issuer.GetHashCode(); + if (notBeforeUtc_ != null) hash ^= NotBeforeUtc.GetHashCode(); + if (notAfterUtc_ != null) hash ^= NotAfterUtc.GetHashCode(); + if (DerBase64.Length != 0) hash ^= DerBase64.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (Subject.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Subject); + } + if (Issuer.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Issuer); + } + if (notBeforeUtc_ != null) { + output.WriteRawTag(34); + output.WriteMessage(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotAfterUtc); + } + if (DerBase64.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DerBase64); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (Subject.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Subject); + } + if (Issuer.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Issuer); + } + if (notBeforeUtc_ != null) { + output.WriteRawTag(34); + output.WriteMessage(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotAfterUtc); + } + if (DerBase64.Length != 0) { + output.WriteRawTag(50); + output.WriteString(DerBase64); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Thumbprint.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Thumbprint); + } + if (Subject.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Subject); + } + if (Issuer.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Issuer); + } + if (notBeforeUtc_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NotAfterUtc); + } + if (DerBase64.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DerBase64); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ServerCertInfoDto other) { + if (other == null) { + return; + } + if (other.Thumbprint.Length != 0) { + Thumbprint = other.Thumbprint; + } + if (other.Subject.Length != 0) { + Subject = other.Subject; + } + if (other.Issuer.Length != 0) { + Issuer = other.Issuer; + } + if (other.notBeforeUtc_ != null) { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + NotBeforeUtc.MergeFrom(other.NotBeforeUtc); + } + if (other.notAfterUtc_ != null) { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + NotAfterUtc.MergeFrom(other.NotAfterUtc); + } + if (other.DerBase64.Length != 0) { + DerBase64 = other.DerBase64; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + Subject = input.ReadString(); + break; + } + case 26: { + Issuer = input.ReadString(); + break; + } + case 34: { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotBeforeUtc); + break; + } + case 42: { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotAfterUtc); + break; + } + case 50: { + DerBase64 = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + Subject = input.ReadString(); + break; + } + case 26: { + Issuer = input.ReadString(); + break; + } + case 34: { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotBeforeUtc); + break; + } + case 42: { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotAfterUtc); + break; + } + case 50: { + DerBase64 = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// failure_kind is a NULLABLE enum on the CLR side, and proto3 enums have no + /// presence, so it rides inside a one-field message exactly like Int32Value. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class VerifyFailureKindValue : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new VerifyFailureKindValue()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[41]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyFailureKindValue() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyFailureKindValue(VerifyFailureKindValue other) : this() { + value_ = other.value_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyFailureKindValue Clone() { + return new VerifyFailureKindValue(this); + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 1; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto value_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto Value { + get { return value_; } + set { + value_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as VerifyFailureKindValue); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(VerifyFailureKindValue other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Value != other.Value) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Value != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified) hash ^= Value.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Value != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Value != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified) { + output.WriteRawTag(8); + output.WriteEnum((int) Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Value != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(VerifyFailureKindValue other) { + if (other == null) { + return; + } + if (other.Value != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto.Unspecified) { + Value = other.Value; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Value = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto) input.ReadEnum(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Value = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindDto) input.ReadEnum(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class VerifyEndpointResultDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new VerifyEndpointResultDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[42]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointResultDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointResultDto(VerifyEndpointResultDto other) : this() { + success_ = other.success_; + failureKind_ = other.failureKind_ != null ? other.failureKind_.Clone() : null; + error_ = other.error_; + cert_ = other.cert_ != null ? other.cert_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public VerifyEndpointResultDto Clone() { + return new VerifyEndpointResultDto(this); + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 1; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "failure_kind" field. + public const int FailureKindFieldNumber = 2; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue failureKind_; + /// + /// absent => null (success) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue FailureKind { + get { return failureKind_; } + set { + failureKind_ = value; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + private string error_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "cert" field. + public const int CertFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto cert_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto Cert { + get { return cert_; } + set { + cert_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as VerifyEndpointResultDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(VerifyEndpointResultDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Success != other.Success) return false; + if (!object.Equals(FailureKind, other.FailureKind)) return false; + if (Error != other.Error) return false; + if (!object.Equals(Cert, other.Cert)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Success != false) hash ^= Success.GetHashCode(); + if (failureKind_ != null) hash ^= FailureKind.GetHashCode(); + if (Error.Length != 0) hash ^= Error.GetHashCode(); + if (cert_ != null) hash ^= Cert.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Success != false) { + output.WriteRawTag(8); + output.WriteBool(Success); + } + if (failureKind_ != null) { + output.WriteRawTag(18); + output.WriteMessage(FailureKind); + } + if (Error.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (cert_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Cert); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Success != false) { + output.WriteRawTag(8); + output.WriteBool(Success); + } + if (failureKind_ != null) { + output.WriteRawTag(18); + output.WriteMessage(FailureKind); + } + if (Error.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (cert_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Cert); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Success != false) { + size += 1 + 1; + } + if (failureKind_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(FailureKind); + } + if (Error.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (cert_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Cert); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(VerifyEndpointResultDto other) { + if (other == null) { + return; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.failureKind_ != null) { + if (failureKind_ == null) { + FailureKind = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue(); + } + FailureKind.MergeFrom(other.FailureKind); + } + if (other.Error.Length != 0) { + Error = other.Error; + } + if (other.cert_ != null) { + if (cert_ == null) { + Cert = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto(); + } + Cert.MergeFrom(other.Cert); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Success = input.ReadBool(); + break; + } + case 18: { + if (failureKind_ == null) { + FailureKind = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue(); + } + input.ReadMessage(FailureKind); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + case 34: { + if (cert_ == null) { + Cert = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto(); + } + input.ReadMessage(Cert); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Success = input.ReadBool(); + break; + } + case 18: { + if (failureKind_ == null) { + FailureKind = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyFailureKindValue(); + } + input.ReadMessage(FailureKind); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + case 34: { + if (cert_ == null) { + Cert = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ServerCertInfoDto(); + } + input.ReadMessage(Cert); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TrustServerCertCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TrustServerCertCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[43]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustServerCertCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustServerCertCommandDto(TrustServerCertCommandDto other) : this() { + connectionName_ = other.connectionName_; + derBase64_ = other.derBase64_; + thumbprint_ = other.thumbprint_; + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustServerCertCommandDto Clone() { + return new TrustServerCertCommandDto(this); + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 1; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "der_base64" field. + public const int DerBase64FieldNumber = 2; + private string derBase64_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string DerBase64 { + get { return derBase64_; } + set { + derBase64_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "thumbprint" field. + public const int ThumbprintFieldNumber = 3; + private string thumbprint_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Thumbprint { + get { return thumbprint_; } + set { + thumbprint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 4; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TrustServerCertCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TrustServerCertCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ConnectionName != other.ConnectionName) return false; + if (DerBase64 != other.DerBase64) return false; + if (Thumbprint != other.Thumbprint) return false; + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + if (DerBase64.Length != 0) hash ^= DerBase64.GetHashCode(); + if (Thumbprint.Length != 0) hash ^= Thumbprint.GetHashCode(); + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (DerBase64.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DerBase64); + } + if (Thumbprint.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (ConnectionName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(ConnectionName); + } + if (DerBase64.Length != 0) { + output.WriteRawTag(18); + output.WriteString(DerBase64); + } + if (Thumbprint.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(34); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + if (DerBase64.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DerBase64); + } + if (Thumbprint.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TrustServerCertCommandDto other) { + if (other == null) { + return; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + if (other.DerBase64.Length != 0) { + DerBase64 = other.DerBase64; + } + if (other.Thumbprint.Length != 0) { + Thumbprint = other.Thumbprint; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + DerBase64 = input.ReadString(); + break; + } + case 26: { + Thumbprint = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ConnectionName = input.ReadString(); + break; + } + case 18: { + DerBase64 = input.ReadString(); + break; + } + case 26: { + Thumbprint = input.ReadString(); + break; + } + case 34: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ListServerCertsCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ListServerCertsCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[44]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListServerCertsCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListServerCertsCommandDto(ListServerCertsCommandDto other) : this() { + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ListServerCertsCommandDto Clone() { + return new ListServerCertsCommandDto(this); + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 1; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ListServerCertsCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ListServerCertsCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(10); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(10); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ListServerCertsCommandDto other) { + if (other == null) { + return; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RemoveServerCertCommandDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RemoveServerCertCommandDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[45]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveServerCertCommandDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveServerCertCommandDto(RemoveServerCertCommandDto other) : this() { + thumbprint_ = other.thumbprint_; + siteIdentifier_ = other.siteIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RemoveServerCertCommandDto Clone() { + return new RemoveServerCertCommandDto(this); + } + + /// Field number for the "thumbprint" field. + public const int ThumbprintFieldNumber = 1; + private string thumbprint_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Thumbprint { + get { return thumbprint_; } + set { + thumbprint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_identifier" field. + public const int SiteIdentifierFieldNumber = 2; + private string siteIdentifier_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteIdentifier { + get { return siteIdentifier_; } + set { + siteIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RemoveServerCertCommandDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RemoveServerCertCommandDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Thumbprint != other.Thumbprint) return false; + if (SiteIdentifier != other.SiteIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Thumbprint.Length != 0) hash ^= Thumbprint.GetHashCode(); + if (SiteIdentifier.Length != 0) hash ^= SiteIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Thumbprint.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Thumbprint); + } + if (SiteIdentifier.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RemoveServerCertCommandDto other) { + if (other == null) { + return; + } + if (other.Thumbprint.Length != 0) { + Thumbprint = other.Thumbprint; + } + if (other.SiteIdentifier.Length != 0) { + SiteIdentifier = other.SiteIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + SiteIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TrustedCertInfoDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TrustedCertInfoDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[46]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoDto(TrustedCertInfoDto other) : this() { + thumbprint_ = other.thumbprint_; + subject_ = other.subject_; + issuer_ = other.issuer_; + notBeforeUtc_ = other.notBeforeUtc_ != null ? other.notBeforeUtc_.Clone() : null; + notAfterUtc_ = other.notAfterUtc_ != null ? other.notAfterUtc_.Clone() : null; + rejected_ = other.rejected_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoDto Clone() { + return new TrustedCertInfoDto(this); + } + + /// Field number for the "thumbprint" field. + public const int ThumbprintFieldNumber = 1; + private string thumbprint_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Thumbprint { + get { return thumbprint_; } + set { + thumbprint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "subject" field. + public const int SubjectFieldNumber = 2; + private string subject_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Subject { + get { return subject_; } + set { + subject_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "issuer" field. + public const int IssuerFieldNumber = 3; + private string issuer_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Issuer { + get { return issuer_; } + set { + issuer_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "not_before_utc" field. + public const int NotBeforeUtcFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp notBeforeUtc_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp NotBeforeUtc { + get { return notBeforeUtc_; } + set { + notBeforeUtc_ = value; + } + } + + /// Field number for the "not_after_utc" field. + public const int NotAfterUtcFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp notAfterUtc_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp NotAfterUtc { + get { return notAfterUtc_; } + set { + notAfterUtc_ = value; + } + } + + /// Field number for the "rejected" field. + public const int RejectedFieldNumber = 6; + private bool rejected_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Rejected { + get { return rejected_; } + set { + rejected_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TrustedCertInfoDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TrustedCertInfoDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Thumbprint != other.Thumbprint) return false; + if (Subject != other.Subject) return false; + if (Issuer != other.Issuer) return false; + if (!object.Equals(NotBeforeUtc, other.NotBeforeUtc)) return false; + if (!object.Equals(NotAfterUtc, other.NotAfterUtc)) return false; + if (Rejected != other.Rejected) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Thumbprint.Length != 0) hash ^= Thumbprint.GetHashCode(); + if (Subject.Length != 0) hash ^= Subject.GetHashCode(); + if (Issuer.Length != 0) hash ^= Issuer.GetHashCode(); + if (notBeforeUtc_ != null) hash ^= NotBeforeUtc.GetHashCode(); + if (notAfterUtc_ != null) hash ^= NotAfterUtc.GetHashCode(); + if (Rejected != false) hash ^= Rejected.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (Subject.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Subject); + } + if (Issuer.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Issuer); + } + if (notBeforeUtc_ != null) { + output.WriteRawTag(34); + output.WriteMessage(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotAfterUtc); + } + if (Rejected != false) { + output.WriteRawTag(48); + output.WriteBool(Rejected); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Thumbprint.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Thumbprint); + } + if (Subject.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Subject); + } + if (Issuer.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Issuer); + } + if (notBeforeUtc_ != null) { + output.WriteRawTag(34); + output.WriteMessage(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + output.WriteRawTag(42); + output.WriteMessage(NotAfterUtc); + } + if (Rejected != false) { + output.WriteRawTag(48); + output.WriteBool(Rejected); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Thumbprint.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Thumbprint); + } + if (Subject.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Subject); + } + if (Issuer.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Issuer); + } + if (notBeforeUtc_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NotBeforeUtc); + } + if (notAfterUtc_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(NotAfterUtc); + } + if (Rejected != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TrustedCertInfoDto other) { + if (other == null) { + return; + } + if (other.Thumbprint.Length != 0) { + Thumbprint = other.Thumbprint; + } + if (other.Subject.Length != 0) { + Subject = other.Subject; + } + if (other.Issuer.Length != 0) { + Issuer = other.Issuer; + } + if (other.notBeforeUtc_ != null) { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + NotBeforeUtc.MergeFrom(other.NotBeforeUtc); + } + if (other.notAfterUtc_ != null) { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + NotAfterUtc.MergeFrom(other.NotAfterUtc); + } + if (other.Rejected != false) { + Rejected = other.Rejected; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + Subject = input.ReadString(); + break; + } + case 26: { + Issuer = input.ReadString(); + break; + } + case 34: { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotBeforeUtc); + break; + } + case 42: { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotAfterUtc); + break; + } + case 48: { + Rejected = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Thumbprint = input.ReadString(); + break; + } + case 18: { + Subject = input.ReadString(); + break; + } + case 26: { + Issuer = input.ReadString(); + break; + } + case 34: { + if (notBeforeUtc_ == null) { + NotBeforeUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotBeforeUtc); + break; + } + case 42: { + if (notAfterUtc_ == null) { + NotAfterUtc = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(NotAfterUtc); + break; + } + case 48: { + Rejected = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// CertTrustResult.Certs is a nullable list (null for trust/remove, populated + /// for list) — same null-vs-empty problem as the artifact collections. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TrustedCertInfoListDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TrustedCertInfoListDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[47]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoListDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoListDto(TrustedCertInfoListDto other) : this() { + items_ = other.items_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TrustedCertInfoListDto Clone() { + return new TrustedCertInfoListDto(this); + } + + /// Field number for the "items" field. + public const int ItemsFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_items_codec + = pb::FieldCodec.ForMessage(10, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoDto.Parser); + private readonly pbc::RepeatedField items_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Items { + get { return items_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TrustedCertInfoListDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TrustedCertInfoListDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!items_.Equals(other.items_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + hash ^= items_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + items_.WriteTo(output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + items_.WriteTo(ref output, _repeated_items_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + size += items_.CalculateSize(_repeated_items_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TrustedCertInfoListDto other) { + if (other == null) { + return; + } + items_.Add(other.items_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + items_.AddEntriesFrom(input, _repeated_items_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + items_.AddEntriesFrom(ref input, _repeated_items_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class CertTrustResultDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new CertTrustResultDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[48]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CertTrustResultDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CertTrustResultDto(CertTrustResultDto other) : this() { + success_ = other.success_; + error_ = other.error_; + certs_ = other.certs_ != null ? other.certs_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CertTrustResultDto Clone() { + return new CertTrustResultDto(this); + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 1; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private string error_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "certs" field. + public const int CertsFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto certs_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto Certs { + get { return certs_; } + set { + certs_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as CertTrustResultDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(CertTrustResultDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Success != other.Success) return false; + if (Error != other.Error) return false; + if (!object.Equals(Certs, other.Certs)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Success != false) hash ^= Success.GetHashCode(); + if (Error.Length != 0) hash ^= Error.GetHashCode(); + if (certs_ != null) hash ^= Certs.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Success != false) { + output.WriteRawTag(8); + output.WriteBool(Success); + } + if (Error.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (certs_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Certs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Success != false) { + output.WriteRawTag(8); + output.WriteBool(Success); + } + if (Error.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (certs_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Certs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Success != false) { + size += 1 + 1; + } + if (Error.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (certs_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Certs); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(CertTrustResultDto other) { + if (other == null) { + return; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.Error.Length != 0) { + Error = other.Error; + } + if (other.certs_ != null) { + if (certs_ == null) { + Certs = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto(); + } + Certs.MergeFrom(other.Certs); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Success = input.ReadBool(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + case 26: { + if (certs_ == null) { + Certs = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto(); + } + input.ReadMessage(Certs); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Success = input.ReadBool(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + case 26: { + if (certs_ == null) { + Certs = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustedCertInfoListDto(); + } + input.ReadMessage(Certs); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class WriteTagRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new WriteTagRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[49]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagRequestDto(WriteTagRequestDto other) : this() { + correlationId_ = other.correlationId_; + connectionName_ = other.connectionName_; + tagPath_ = other.tagPath_; + value_ = other.value_ != null ? other.value_.Clone() : null; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagRequestDto Clone() { + return new WriteTagRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "connection_name" field. + public const int ConnectionNameFieldNumber = 2; + private string connectionName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ConnectionName { + get { return connectionName_; } + set { + connectionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tag_path" field. + public const int TagPathFieldNumber = 3; + private string tagPath_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TagPath { + get { return tagPath_; } + set { + tagPath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue value_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue Value { + get { return value_; } + set { + value_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as WriteTagRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(WriteTagRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (ConnectionName != other.ConnectionName) return false; + if (TagPath != other.TagPath) return false; + if (!object.Equals(Value, other.Value)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (ConnectionName.Length != 0) hash ^= ConnectionName.GetHashCode(); + if (TagPath.Length != 0) hash ^= TagPath.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (ConnectionName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ConnectionName); + } + if (TagPath.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TagPath); + } + if (value_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Value); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (ConnectionName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(ConnectionName); + } + if (TagPath.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TagPath); + } + if (value_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Value); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (ConnectionName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ConnectionName); + } + if (TagPath.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TagPath); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(WriteTagRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.ConnectionName.Length != 0) { + ConnectionName = other.ConnectionName; + } + if (other.TagPath.Length != 0) { + TagPath = other.TagPath; + } + if (other.value_ != null) { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + Value.MergeFrom(other.Value); + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + ConnectionName = input.ReadString(); + break; + } + case 26: { + TagPath = input.ReadString(); + break; + } + case 34: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + ConnectionName = input.ReadString(); + break; + } + case 26: { + TagPath = input.ReadString(); + break; + } + case 34: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class WriteTagResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new WriteTagResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[50]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagResponseDto(WriteTagResponseDto other) : this() { + correlationId_ = other.correlationId_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public WriteTagResponseDto Clone() { + return new WriteTagResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 3; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as WriteTagResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(WriteTagResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(WriteTagResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OpcUaRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OpcUaRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[51]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaRequest(OpcUaRequest other) : this() { + switch (other.CommandCase) { + case CommandOneofCase.BrowseNode: + BrowseNode = other.BrowseNode.Clone(); + break; + case CommandOneofCase.SearchAddressSpace: + SearchAddressSpace = other.SearchAddressSpace.Clone(); + break; + case CommandOneofCase.ReadTagValues: + ReadTagValues = other.ReadTagValues.Clone(); + break; + case CommandOneofCase.VerifyEndpoint: + VerifyEndpoint = other.VerifyEndpoint.Clone(); + break; + case CommandOneofCase.TrustServerCert: + TrustServerCert = other.TrustServerCert.Clone(); + break; + case CommandOneofCase.ListServerCerts: + ListServerCerts = other.ListServerCerts.Clone(); + break; + case CommandOneofCase.RemoveServerCert: + RemoveServerCert = other.RemoveServerCert.Clone(); + break; + case CommandOneofCase.WriteTag: + WriteTag = other.WriteTag.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaRequest Clone() { + return new OpcUaRequest(this); + } + + /// Field number for the "browse_node" field. + public const int BrowseNodeFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto BrowseNode { + get { return commandCase_ == CommandOneofCase.BrowseNode ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.BrowseNode; + } + } + + /// Field number for the "search_address_space" field. + public const int SearchAddressSpaceFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto SearchAddressSpace { + get { return commandCase_ == CommandOneofCase.SearchAddressSpace ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.SearchAddressSpace; + } + } + + /// Field number for the "read_tag_values" field. + public const int ReadTagValuesFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto ReadTagValues { + get { return commandCase_ == CommandOneofCase.ReadTagValues ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.ReadTagValues; + } + } + + /// Field number for the "verify_endpoint" field. + public const int VerifyEndpointFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto VerifyEndpoint { + get { return commandCase_ == CommandOneofCase.VerifyEndpoint ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.VerifyEndpoint; + } + } + + /// Field number for the "trust_server_cert" field. + public const int TrustServerCertFieldNumber = 5; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto TrustServerCert { + get { return commandCase_ == CommandOneofCase.TrustServerCert ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.TrustServerCert; + } + } + + /// Field number for the "list_server_certs" field. + public const int ListServerCertsFieldNumber = 6; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto ListServerCerts { + get { return commandCase_ == CommandOneofCase.ListServerCerts ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.ListServerCerts; + } + } + + /// Field number for the "remove_server_cert" field. + public const int RemoveServerCertFieldNumber = 7; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto RemoveServerCert { + get { return commandCase_ == CommandOneofCase.RemoveServerCert ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RemoveServerCert; + } + } + + /// Field number for the "write_tag" field. + public const int WriteTagFieldNumber = 8; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto WriteTag { + get { return commandCase_ == CommandOneofCase.WriteTag ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.WriteTag; + } + } + + private object command_; + /// Enum of possible cases for the "command" oneof. + public enum CommandOneofCase { + None = 0, + BrowseNode = 1, + SearchAddressSpace = 2, + ReadTagValues = 3, + VerifyEndpoint = 4, + TrustServerCert = 5, + ListServerCerts = 6, + RemoveServerCert = 7, + WriteTag = 8, + } + private CommandOneofCase commandCase_ = CommandOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CommandOneofCase CommandCase { + get { return commandCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearCommand() { + commandCase_ = CommandOneofCase.None; + command_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OpcUaRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OpcUaRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(BrowseNode, other.BrowseNode)) return false; + if (!object.Equals(SearchAddressSpace, other.SearchAddressSpace)) return false; + if (!object.Equals(ReadTagValues, other.ReadTagValues)) return false; + if (!object.Equals(VerifyEndpoint, other.VerifyEndpoint)) return false; + if (!object.Equals(TrustServerCert, other.TrustServerCert)) return false; + if (!object.Equals(ListServerCerts, other.ListServerCerts)) return false; + if (!object.Equals(RemoveServerCert, other.RemoveServerCert)) return false; + if (!object.Equals(WriteTag, other.WriteTag)) return false; + if (CommandCase != other.CommandCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (commandCase_ == CommandOneofCase.BrowseNode) hash ^= BrowseNode.GetHashCode(); + if (commandCase_ == CommandOneofCase.SearchAddressSpace) hash ^= SearchAddressSpace.GetHashCode(); + if (commandCase_ == CommandOneofCase.ReadTagValues) hash ^= ReadTagValues.GetHashCode(); + if (commandCase_ == CommandOneofCase.VerifyEndpoint) hash ^= VerifyEndpoint.GetHashCode(); + if (commandCase_ == CommandOneofCase.TrustServerCert) hash ^= TrustServerCert.GetHashCode(); + if (commandCase_ == CommandOneofCase.ListServerCerts) hash ^= ListServerCerts.GetHashCode(); + if (commandCase_ == CommandOneofCase.RemoveServerCert) hash ^= RemoveServerCert.GetHashCode(); + if (commandCase_ == CommandOneofCase.WriteTag) hash ^= WriteTag.GetHashCode(); + hash ^= (int) commandCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (commandCase_ == CommandOneofCase.BrowseNode) { + output.WriteRawTag(10); + output.WriteMessage(BrowseNode); + } + if (commandCase_ == CommandOneofCase.SearchAddressSpace) { + output.WriteRawTag(18); + output.WriteMessage(SearchAddressSpace); + } + if (commandCase_ == CommandOneofCase.ReadTagValues) { + output.WriteRawTag(26); + output.WriteMessage(ReadTagValues); + } + if (commandCase_ == CommandOneofCase.VerifyEndpoint) { + output.WriteRawTag(34); + output.WriteMessage(VerifyEndpoint); + } + if (commandCase_ == CommandOneofCase.TrustServerCert) { + output.WriteRawTag(42); + output.WriteMessage(TrustServerCert); + } + if (commandCase_ == CommandOneofCase.ListServerCerts) { + output.WriteRawTag(50); + output.WriteMessage(ListServerCerts); + } + if (commandCase_ == CommandOneofCase.RemoveServerCert) { + output.WriteRawTag(58); + output.WriteMessage(RemoveServerCert); + } + if (commandCase_ == CommandOneofCase.WriteTag) { + output.WriteRawTag(66); + output.WriteMessage(WriteTag); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (commandCase_ == CommandOneofCase.BrowseNode) { + output.WriteRawTag(10); + output.WriteMessage(BrowseNode); + } + if (commandCase_ == CommandOneofCase.SearchAddressSpace) { + output.WriteRawTag(18); + output.WriteMessage(SearchAddressSpace); + } + if (commandCase_ == CommandOneofCase.ReadTagValues) { + output.WriteRawTag(26); + output.WriteMessage(ReadTagValues); + } + if (commandCase_ == CommandOneofCase.VerifyEndpoint) { + output.WriteRawTag(34); + output.WriteMessage(VerifyEndpoint); + } + if (commandCase_ == CommandOneofCase.TrustServerCert) { + output.WriteRawTag(42); + output.WriteMessage(TrustServerCert); + } + if (commandCase_ == CommandOneofCase.ListServerCerts) { + output.WriteRawTag(50); + output.WriteMessage(ListServerCerts); + } + if (commandCase_ == CommandOneofCase.RemoveServerCert) { + output.WriteRawTag(58); + output.WriteMessage(RemoveServerCert); + } + if (commandCase_ == CommandOneofCase.WriteTag) { + output.WriteRawTag(66); + output.WriteMessage(WriteTag); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (commandCase_ == CommandOneofCase.BrowseNode) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(BrowseNode); + } + if (commandCase_ == CommandOneofCase.SearchAddressSpace) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SearchAddressSpace); + } + if (commandCase_ == CommandOneofCase.ReadTagValues) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReadTagValues); + } + if (commandCase_ == CommandOneofCase.VerifyEndpoint) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(VerifyEndpoint); + } + if (commandCase_ == CommandOneofCase.TrustServerCert) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(TrustServerCert); + } + if (commandCase_ == CommandOneofCase.ListServerCerts) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ListServerCerts); + } + if (commandCase_ == CommandOneofCase.RemoveServerCert) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RemoveServerCert); + } + if (commandCase_ == CommandOneofCase.WriteTag) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(WriteTag); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OpcUaRequest other) { + if (other == null) { + return; + } + switch (other.CommandCase) { + case CommandOneofCase.BrowseNode: + if (BrowseNode == null) { + BrowseNode = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto(); + } + BrowseNode.MergeFrom(other.BrowseNode); + break; + case CommandOneofCase.SearchAddressSpace: + if (SearchAddressSpace == null) { + SearchAddressSpace = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto(); + } + SearchAddressSpace.MergeFrom(other.SearchAddressSpace); + break; + case CommandOneofCase.ReadTagValues: + if (ReadTagValues == null) { + ReadTagValues = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto(); + } + ReadTagValues.MergeFrom(other.ReadTagValues); + break; + case CommandOneofCase.VerifyEndpoint: + if (VerifyEndpoint == null) { + VerifyEndpoint = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto(); + } + VerifyEndpoint.MergeFrom(other.VerifyEndpoint); + break; + case CommandOneofCase.TrustServerCert: + if (TrustServerCert == null) { + TrustServerCert = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto(); + } + TrustServerCert.MergeFrom(other.TrustServerCert); + break; + case CommandOneofCase.ListServerCerts: + if (ListServerCerts == null) { + ListServerCerts = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto(); + } + ListServerCerts.MergeFrom(other.ListServerCerts); + break; + case CommandOneofCase.RemoveServerCert: + if (RemoveServerCert == null) { + RemoveServerCert = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto(); + } + RemoveServerCert.MergeFrom(other.RemoveServerCert); + break; + case CommandOneofCase.WriteTag: + if (WriteTag == null) { + WriteTag = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto(); + } + WriteTag.MergeFrom(other.WriteTag); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto(); + if (commandCase_ == CommandOneofCase.BrowseNode) { + subBuilder.MergeFrom(BrowseNode); + } + input.ReadMessage(subBuilder); + BrowseNode = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto(); + if (commandCase_ == CommandOneofCase.SearchAddressSpace) { + subBuilder.MergeFrom(SearchAddressSpace); + } + input.ReadMessage(subBuilder); + SearchAddressSpace = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto(); + if (commandCase_ == CommandOneofCase.ReadTagValues) { + subBuilder.MergeFrom(ReadTagValues); + } + input.ReadMessage(subBuilder); + ReadTagValues = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto(); + if (commandCase_ == CommandOneofCase.VerifyEndpoint) { + subBuilder.MergeFrom(VerifyEndpoint); + } + input.ReadMessage(subBuilder); + VerifyEndpoint = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto(); + if (commandCase_ == CommandOneofCase.TrustServerCert) { + subBuilder.MergeFrom(TrustServerCert); + } + input.ReadMessage(subBuilder); + TrustServerCert = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto(); + if (commandCase_ == CommandOneofCase.ListServerCerts) { + subBuilder.MergeFrom(ListServerCerts); + } + input.ReadMessage(subBuilder); + ListServerCerts = subBuilder; + break; + } + case 58: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto(); + if (commandCase_ == CommandOneofCase.RemoveServerCert) { + subBuilder.MergeFrom(RemoveServerCert); + } + input.ReadMessage(subBuilder); + RemoveServerCert = subBuilder; + break; + } + case 66: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto(); + if (commandCase_ == CommandOneofCase.WriteTag) { + subBuilder.MergeFrom(WriteTag); + } + input.ReadMessage(subBuilder); + WriteTag = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeCommandDto(); + if (commandCase_ == CommandOneofCase.BrowseNode) { + subBuilder.MergeFrom(BrowseNode); + } + input.ReadMessage(subBuilder); + BrowseNode = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceCommandDto(); + if (commandCase_ == CommandOneofCase.SearchAddressSpace) { + subBuilder.MergeFrom(SearchAddressSpace); + } + input.ReadMessage(subBuilder); + SearchAddressSpace = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesCommandDto(); + if (commandCase_ == CommandOneofCase.ReadTagValues) { + subBuilder.MergeFrom(ReadTagValues); + } + input.ReadMessage(subBuilder); + ReadTagValues = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointCommandDto(); + if (commandCase_ == CommandOneofCase.VerifyEndpoint) { + subBuilder.MergeFrom(VerifyEndpoint); + } + input.ReadMessage(subBuilder); + VerifyEndpoint = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TrustServerCertCommandDto(); + if (commandCase_ == CommandOneofCase.TrustServerCert) { + subBuilder.MergeFrom(TrustServerCert); + } + input.ReadMessage(subBuilder); + TrustServerCert = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ListServerCertsCommandDto(); + if (commandCase_ == CommandOneofCase.ListServerCerts) { + subBuilder.MergeFrom(ListServerCerts); + } + input.ReadMessage(subBuilder); + ListServerCerts = subBuilder; + break; + } + case 58: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RemoveServerCertCommandDto(); + if (commandCase_ == CommandOneofCase.RemoveServerCert) { + subBuilder.MergeFrom(RemoveServerCert); + } + input.ReadMessage(subBuilder); + RemoveServerCert = subBuilder; + break; + } + case 66: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagRequestDto(); + if (commandCase_ == CommandOneofCase.WriteTag) { + subBuilder.MergeFrom(WriteTag); + } + input.ReadMessage(subBuilder); + WriteTag = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OpcUaReply : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OpcUaReply()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[52]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaReply() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaReply(OpcUaReply other) : this() { + switch (other.ReplyCase) { + case ReplyOneofCase.BrowseNode: + BrowseNode = other.BrowseNode.Clone(); + break; + case ReplyOneofCase.SearchAddressSpace: + SearchAddressSpace = other.SearchAddressSpace.Clone(); + break; + case ReplyOneofCase.ReadTagValues: + ReadTagValues = other.ReadTagValues.Clone(); + break; + case ReplyOneofCase.VerifyEndpoint: + VerifyEndpoint = other.VerifyEndpoint.Clone(); + break; + case ReplyOneofCase.CertTrust: + CertTrust = other.CertTrust.Clone(); + break; + case ReplyOneofCase.WriteTag: + WriteTag = other.WriteTag.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OpcUaReply Clone() { + return new OpcUaReply(this); + } + + /// Field number for the "browse_node" field. + public const int BrowseNodeFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto BrowseNode { + get { return replyCase_ == ReplyOneofCase.BrowseNode ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.BrowseNode; + } + } + + /// Field number for the "search_address_space" field. + public const int SearchAddressSpaceFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto SearchAddressSpace { + get { return replyCase_ == ReplyOneofCase.SearchAddressSpace ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.SearchAddressSpace; + } + } + + /// Field number for the "read_tag_values" field. + public const int ReadTagValuesFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto ReadTagValues { + get { return replyCase_ == ReplyOneofCase.ReadTagValues ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ReadTagValues; + } + } + + /// Field number for the "verify_endpoint" field. + public const int VerifyEndpointFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto VerifyEndpoint { + get { return replyCase_ == ReplyOneofCase.VerifyEndpoint ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.VerifyEndpoint; + } + } + + /// Field number for the "cert_trust" field. + public const int CertTrustFieldNumber = 5; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto CertTrust { + get { return replyCase_ == ReplyOneofCase.CertTrust ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.CertTrust; + } + } + + /// Field number for the "write_tag" field. + public const int WriteTagFieldNumber = 6; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto WriteTag { + get { return replyCase_ == ReplyOneofCase.WriteTag ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.WriteTag; + } + } + + private object reply_; + /// Enum of possible cases for the "reply" oneof. + public enum ReplyOneofCase { + None = 0, + BrowseNode = 1, + SearchAddressSpace = 2, + ReadTagValues = 3, + VerifyEndpoint = 4, + CertTrust = 5, + WriteTag = 6, + } + private ReplyOneofCase replyCase_ = ReplyOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReplyOneofCase ReplyCase { + get { return replyCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReply() { + replyCase_ = ReplyOneofCase.None; + reply_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OpcUaReply); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OpcUaReply other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(BrowseNode, other.BrowseNode)) return false; + if (!object.Equals(SearchAddressSpace, other.SearchAddressSpace)) return false; + if (!object.Equals(ReadTagValues, other.ReadTagValues)) return false; + if (!object.Equals(VerifyEndpoint, other.VerifyEndpoint)) return false; + if (!object.Equals(CertTrust, other.CertTrust)) return false; + if (!object.Equals(WriteTag, other.WriteTag)) return false; + if (ReplyCase != other.ReplyCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (replyCase_ == ReplyOneofCase.BrowseNode) hash ^= BrowseNode.GetHashCode(); + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) hash ^= SearchAddressSpace.GetHashCode(); + if (replyCase_ == ReplyOneofCase.ReadTagValues) hash ^= ReadTagValues.GetHashCode(); + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) hash ^= VerifyEndpoint.GetHashCode(); + if (replyCase_ == ReplyOneofCase.CertTrust) hash ^= CertTrust.GetHashCode(); + if (replyCase_ == ReplyOneofCase.WriteTag) hash ^= WriteTag.GetHashCode(); + hash ^= (int) replyCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (replyCase_ == ReplyOneofCase.BrowseNode) { + output.WriteRawTag(10); + output.WriteMessage(BrowseNode); + } + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) { + output.WriteRawTag(18); + output.WriteMessage(SearchAddressSpace); + } + if (replyCase_ == ReplyOneofCase.ReadTagValues) { + output.WriteRawTag(26); + output.WriteMessage(ReadTagValues); + } + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) { + output.WriteRawTag(34); + output.WriteMessage(VerifyEndpoint); + } + if (replyCase_ == ReplyOneofCase.CertTrust) { + output.WriteRawTag(42); + output.WriteMessage(CertTrust); + } + if (replyCase_ == ReplyOneofCase.WriteTag) { + output.WriteRawTag(50); + output.WriteMessage(WriteTag); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (replyCase_ == ReplyOneofCase.BrowseNode) { + output.WriteRawTag(10); + output.WriteMessage(BrowseNode); + } + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) { + output.WriteRawTag(18); + output.WriteMessage(SearchAddressSpace); + } + if (replyCase_ == ReplyOneofCase.ReadTagValues) { + output.WriteRawTag(26); + output.WriteMessage(ReadTagValues); + } + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) { + output.WriteRawTag(34); + output.WriteMessage(VerifyEndpoint); + } + if (replyCase_ == ReplyOneofCase.CertTrust) { + output.WriteRawTag(42); + output.WriteMessage(CertTrust); + } + if (replyCase_ == ReplyOneofCase.WriteTag) { + output.WriteRawTag(50); + output.WriteMessage(WriteTag); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (replyCase_ == ReplyOneofCase.BrowseNode) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(BrowseNode); + } + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SearchAddressSpace); + } + if (replyCase_ == ReplyOneofCase.ReadTagValues) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReadTagValues); + } + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(VerifyEndpoint); + } + if (replyCase_ == ReplyOneofCase.CertTrust) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(CertTrust); + } + if (replyCase_ == ReplyOneofCase.WriteTag) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(WriteTag); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OpcUaReply other) { + if (other == null) { + return; + } + switch (other.ReplyCase) { + case ReplyOneofCase.BrowseNode: + if (BrowseNode == null) { + BrowseNode = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto(); + } + BrowseNode.MergeFrom(other.BrowseNode); + break; + case ReplyOneofCase.SearchAddressSpace: + if (SearchAddressSpace == null) { + SearchAddressSpace = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto(); + } + SearchAddressSpace.MergeFrom(other.SearchAddressSpace); + break; + case ReplyOneofCase.ReadTagValues: + if (ReadTagValues == null) { + ReadTagValues = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto(); + } + ReadTagValues.MergeFrom(other.ReadTagValues); + break; + case ReplyOneofCase.VerifyEndpoint: + if (VerifyEndpoint == null) { + VerifyEndpoint = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto(); + } + VerifyEndpoint.MergeFrom(other.VerifyEndpoint); + break; + case ReplyOneofCase.CertTrust: + if (CertTrust == null) { + CertTrust = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto(); + } + CertTrust.MergeFrom(other.CertTrust); + break; + case ReplyOneofCase.WriteTag: + if (WriteTag == null) { + WriteTag = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto(); + } + WriteTag.MergeFrom(other.WriteTag); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto(); + if (replyCase_ == ReplyOneofCase.BrowseNode) { + subBuilder.MergeFrom(BrowseNode); + } + input.ReadMessage(subBuilder); + BrowseNode = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto(); + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) { + subBuilder.MergeFrom(SearchAddressSpace); + } + input.ReadMessage(subBuilder); + SearchAddressSpace = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto(); + if (replyCase_ == ReplyOneofCase.ReadTagValues) { + subBuilder.MergeFrom(ReadTagValues); + } + input.ReadMessage(subBuilder); + ReadTagValues = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto(); + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) { + subBuilder.MergeFrom(VerifyEndpoint); + } + input.ReadMessage(subBuilder); + VerifyEndpoint = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto(); + if (replyCase_ == ReplyOneofCase.CertTrust) { + subBuilder.MergeFrom(CertTrust); + } + input.ReadMessage(subBuilder); + CertTrust = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto(); + if (replyCase_ == ReplyOneofCase.WriteTag) { + subBuilder.MergeFrom(WriteTag); + } + input.ReadMessage(subBuilder); + WriteTag = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.BrowseNodeResultDto(); + if (replyCase_ == ReplyOneofCase.BrowseNode) { + subBuilder.MergeFrom(BrowseNode); + } + input.ReadMessage(subBuilder); + BrowseNode = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SearchAddressSpaceResultDto(); + if (replyCase_ == ReplyOneofCase.SearchAddressSpace) { + subBuilder.MergeFrom(SearchAddressSpace); + } + input.ReadMessage(subBuilder); + SearchAddressSpace = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ReadTagValuesResultDto(); + if (replyCase_ == ReplyOneofCase.ReadTagValues) { + subBuilder.MergeFrom(ReadTagValues); + } + input.ReadMessage(subBuilder); + ReadTagValues = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.VerifyEndpointResultDto(); + if (replyCase_ == ReplyOneofCase.VerifyEndpoint) { + subBuilder.MergeFrom(VerifyEndpoint); + } + input.ReadMessage(subBuilder); + VerifyEndpoint = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.CertTrustResultDto(); + if (replyCase_ == ReplyOneofCase.CertTrust) { + subBuilder.MergeFrom(CertTrust); + } + input.ReadMessage(subBuilder); + CertTrust = subBuilder; + break; + } + case 50: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.WriteTagResponseDto(); + if (replyCase_ == ReplyOneofCase.WriteTag) { + subBuilder.MergeFrom(WriteTag); + } + input.ReadMessage(subBuilder); + WriteTag = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EventLogQueryRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EventLogQueryRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[53]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryRequestDto(EventLogQueryRequestDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + from_ = other.from_ != null ? other.from_.Clone() : null; + to_ = other.to_ != null ? other.to_.Clone() : null; + eventType_ = other.eventType_; + severity_ = other.severity_; + instanceId_ = other.instanceId_; + keywordFilter_ = other.keywordFilter_; + continuationToken_ = other.continuationToken_; + pageSize_ = other.pageSize_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryRequestDto Clone() { + return new EventLogQueryRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "from" field. + public const int FromFieldNumber = 3; + private global::Google.Protobuf.WellKnownTypes.Timestamp from_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp From { + get { return from_; } + set { + from_ = value; + } + } + + /// Field number for the "to" field. + public const int ToFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp to_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp To { + get { return to_; } + set { + to_ = value; + } + } + + /// Field number for the "event_type" field. + public const int EventTypeFieldNumber = 5; + private string eventType_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string EventType { + get { return eventType_; } + set { + eventType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "severity" field. + public const int SeverityFieldNumber = 6; + private string severity_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Severity { + get { return severity_; } + set { + severity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_id" field. + public const int InstanceIdFieldNumber = 7; + private string instanceId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceId { + get { return instanceId_; } + set { + instanceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "keyword_filter" field. + public const int KeywordFilterFieldNumber = 8; + private string keywordFilter_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string KeywordFilter { + get { return keywordFilter_; } + set { + keywordFilter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "continuation_token" field. + public const int ContinuationTokenFieldNumber = 9; + private string continuationToken_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ContinuationToken { + get { return continuationToken_; } + set { + continuationToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 10; + private int pageSize_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageSize { + get { return pageSize_; } + set { + pageSize_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 11; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EventLogQueryRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EventLogQueryRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if (!object.Equals(From, other.From)) return false; + if (!object.Equals(To, other.To)) return false; + if (EventType != other.EventType) return false; + if (Severity != other.Severity) return false; + if (InstanceId != other.InstanceId) return false; + if (KeywordFilter != other.KeywordFilter) return false; + if (ContinuationToken != other.ContinuationToken) return false; + if (PageSize != other.PageSize) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (from_ != null) hash ^= From.GetHashCode(); + if (to_ != null) hash ^= To.GetHashCode(); + if (EventType.Length != 0) hash ^= EventType.GetHashCode(); + if (Severity.Length != 0) hash ^= Severity.GetHashCode(); + if (InstanceId.Length != 0) hash ^= InstanceId.GetHashCode(); + if (KeywordFilter.Length != 0) hash ^= KeywordFilter.GetHashCode(); + if (ContinuationToken.Length != 0) hash ^= ContinuationToken.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (from_ != null) { + output.WriteRawTag(26); + output.WriteMessage(From); + } + if (to_ != null) { + output.WriteRawTag(34); + output.WriteMessage(To); + } + if (EventType.Length != 0) { + output.WriteRawTag(42); + output.WriteString(EventType); + } + if (Severity.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Severity); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(58); + output.WriteString(InstanceId); + } + if (KeywordFilter.Length != 0) { + output.WriteRawTag(66); + output.WriteString(KeywordFilter); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(74); + output.WriteString(ContinuationToken); + } + if (PageSize != 0) { + output.WriteRawTag(80); + output.WriteInt32(PageSize); + } + if (timestamp_ != null) { + output.WriteRawTag(90); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (from_ != null) { + output.WriteRawTag(26); + output.WriteMessage(From); + } + if (to_ != null) { + output.WriteRawTag(34); + output.WriteMessage(To); + } + if (EventType.Length != 0) { + output.WriteRawTag(42); + output.WriteString(EventType); + } + if (Severity.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Severity); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(58); + output.WriteString(InstanceId); + } + if (KeywordFilter.Length != 0) { + output.WriteRawTag(66); + output.WriteString(KeywordFilter); + } + if (ContinuationToken.Length != 0) { + output.WriteRawTag(74); + output.WriteString(ContinuationToken); + } + if (PageSize != 0) { + output.WriteRawTag(80); + output.WriteInt32(PageSize); + } + if (timestamp_ != null) { + output.WriteRawTag(90); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (from_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(From); + } + if (to_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(To); + } + if (EventType.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(EventType); + } + if (Severity.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Severity); + } + if (InstanceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceId); + } + if (KeywordFilter.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(KeywordFilter); + } + if (ContinuationToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ContinuationToken); + } + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EventLogQueryRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + if (other.from_ != null) { + if (from_ == null) { + From = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + From.MergeFrom(other.From); + } + if (other.to_ != null) { + if (to_ == null) { + To = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + To.MergeFrom(other.To); + } + if (other.EventType.Length != 0) { + EventType = other.EventType; + } + if (other.Severity.Length != 0) { + Severity = other.Severity; + } + if (other.InstanceId.Length != 0) { + InstanceId = other.InstanceId; + } + if (other.KeywordFilter.Length != 0) { + KeywordFilter = other.KeywordFilter; + } + if (other.ContinuationToken.Length != 0) { + ContinuationToken = other.ContinuationToken; + } + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + if (from_ == null) { + From = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(From); + break; + } + case 34: { + if (to_ == null) { + To = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(To); + break; + } + case 42: { + EventType = input.ReadString(); + break; + } + case 50: { + Severity = input.ReadString(); + break; + } + case 58: { + InstanceId = input.ReadString(); + break; + } + case 66: { + KeywordFilter = input.ReadString(); + break; + } + case 74: { + ContinuationToken = input.ReadString(); + break; + } + case 80: { + PageSize = input.ReadInt32(); + break; + } + case 90: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + if (from_ == null) { + From = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(From); + break; + } + case 34: { + if (to_ == null) { + To = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(To); + break; + } + case 42: { + EventType = input.ReadString(); + break; + } + case 50: { + Severity = input.ReadString(); + break; + } + case 58: { + InstanceId = input.ReadString(); + break; + } + case 66: { + KeywordFilter = input.ReadString(); + break; + } + case 74: { + ContinuationToken = input.ReadString(); + break; + } + case 80: { + PageSize = input.ReadInt32(); + break; + } + case 90: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EventLogEntryDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EventLogEntryDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[54]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogEntryDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogEntryDto(EventLogEntryDto other) : this() { + id_ = other.id_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + eventType_ = other.eventType_; + severity_ = other.severity_; + instanceId_ = other.instanceId_; + source_ = other.source_; + message_ = other.message_; + details_ = other.details_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogEntryDto Clone() { + return new EventLogEntryDto(this); + } + + /// Field number for the "id" field. + public const int IdFieldNumber = 1; + private string id_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Id { + get { return id_; } + set { + id_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 2; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "event_type" field. + public const int EventTypeFieldNumber = 3; + private string eventType_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string EventType { + get { return eventType_; } + set { + eventType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "severity" field. + public const int SeverityFieldNumber = 4; + private string severity_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Severity { + get { return severity_; } + set { + severity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_id" field. + public const int InstanceIdFieldNumber = 5; + private string instanceId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceId { + get { return instanceId_; } + set { + instanceId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "source" field. + public const int SourceFieldNumber = 6; + private string source_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Source { + get { return source_; } + set { + source_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "message" field. + public const int MessageFieldNumber = 7; + private string message_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Message { + get { return message_; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "details" field. + public const int DetailsFieldNumber = 8; + private string details_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Details { + get { return details_; } + set { + details_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EventLogEntryDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EventLogEntryDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Id != other.Id) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (EventType != other.EventType) return false; + if (Severity != other.Severity) return false; + if (InstanceId != other.InstanceId) return false; + if (Source != other.Source) return false; + if (Message != other.Message) return false; + if (Details != other.Details) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Id.Length != 0) hash ^= Id.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (EventType.Length != 0) hash ^= EventType.GetHashCode(); + if (Severity.Length != 0) hash ^= Severity.GetHashCode(); + if (InstanceId.Length != 0) hash ^= InstanceId.GetHashCode(); + if (Source.Length != 0) hash ^= Source.GetHashCode(); + if (Message.Length != 0) hash ^= Message.GetHashCode(); + if (Details.Length != 0) hash ^= Details.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Id.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (timestamp_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Timestamp); + } + if (EventType.Length != 0) { + output.WriteRawTag(26); + output.WriteString(EventType); + } + if (Severity.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Severity); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(InstanceId); + } + if (Source.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Source); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); + } + if (Details.Length != 0) { + output.WriteRawTag(66); + output.WriteString(Details); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Id.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (timestamp_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Timestamp); + } + if (EventType.Length != 0) { + output.WriteRawTag(26); + output.WriteString(EventType); + } + if (Severity.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Severity); + } + if (InstanceId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(InstanceId); + } + if (Source.Length != 0) { + output.WriteRawTag(50); + output.WriteString(Source); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); + } + if (Details.Length != 0) { + output.WriteRawTag(66); + output.WriteString(Details); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Id.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Id); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (EventType.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(EventType); + } + if (Severity.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Severity); + } + if (InstanceId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceId); + } + if (Source.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Source); + } + if (Message.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Message); + } + if (Details.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Details); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EventLogEntryDto other) { + if (other == null) { + return; + } + if (other.Id.Length != 0) { + Id = other.Id; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.EventType.Length != 0) { + EventType = other.EventType; + } + if (other.Severity.Length != 0) { + Severity = other.Severity; + } + if (other.InstanceId.Length != 0) { + InstanceId = other.InstanceId; + } + if (other.Source.Length != 0) { + Source = other.Source; + } + if (other.Message.Length != 0) { + Message = other.Message; + } + if (other.Details.Length != 0) { + Details = other.Details; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 26: { + EventType = input.ReadString(); + break; + } + case 34: { + Severity = input.ReadString(); + break; + } + case 42: { + InstanceId = input.ReadString(); + break; + } + case 50: { + Source = input.ReadString(); + break; + } + case 58: { + Message = input.ReadString(); + break; + } + case 66: { + Details = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 26: { + EventType = input.ReadString(); + break; + } + case 34: { + Severity = input.ReadString(); + break; + } + case 42: { + InstanceId = input.ReadString(); + break; + } + case 50: { + Source = input.ReadString(); + break; + } + case 58: { + Message = input.ReadString(); + break; + } + case 66: { + Details = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EventLogQueryResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EventLogQueryResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[55]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryResponseDto(EventLogQueryResponseDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + entries_ = other.entries_.Clone(); + continuationToken_ = other.continuationToken_; + hasMore_ = other.hasMore_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EventLogQueryResponseDto Clone() { + return new EventLogQueryResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "entries" field. + public const int EntriesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_entries_codec + = pb::FieldCodec.ForMessage(26, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogEntryDto.Parser); + private readonly pbc::RepeatedField entries_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Entries { + get { return entries_; } + } + + /// Field number for the "continuation_token" field. + public const int ContinuationTokenFieldNumber = 4; + private string continuationToken_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ContinuationToken { + get { return continuationToken_; } + set { + continuationToken_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "has_more" field. + public const int HasMoreFieldNumber = 5; + private bool hasMore_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasMore { + get { return hasMore_; } + set { + hasMore_ = value; + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 6; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 7; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 8; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EventLogQueryResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EventLogQueryResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if(!entries_.Equals(other.entries_)) return false; + if (ContinuationToken != other.ContinuationToken) return false; + if (HasMore != other.HasMore) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + hash ^= entries_.GetHashCode(); + if (ContinuationToken.Length != 0) hash ^= ContinuationToken.GetHashCode(); + if (HasMore != false) hash ^= HasMore.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + entries_.WriteTo(output, _repeated_entries_codec); + if (ContinuationToken.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ContinuationToken); + } + if (HasMore != false) { + output.WriteRawTag(40); + output.WriteBool(HasMore); + } + if (Success != false) { + output.WriteRawTag(48); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + entries_.WriteTo(ref output, _repeated_entries_codec); + if (ContinuationToken.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ContinuationToken); + } + if (HasMore != false) { + output.WriteRawTag(40); + output.WriteBool(HasMore); + } + if (Success != false) { + output.WriteRawTag(48); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + size += entries_.CalculateSize(_repeated_entries_codec); + if (ContinuationToken.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ContinuationToken); + } + if (HasMore != false) { + size += 1 + 1; + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EventLogQueryResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + entries_.Add(other.entries_); + if (other.ContinuationToken.Length != 0) { + ContinuationToken = other.ContinuationToken; + } + if (other.HasMore != false) { + HasMore = other.HasMore; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + entries_.AddEntriesFrom(input, _repeated_entries_codec); + break; + } + case 34: { + ContinuationToken = input.ReadString(); + break; + } + case 40: { + HasMore = input.ReadBool(); + break; + } + case 48: { + Success = input.ReadBool(); + break; + } + case 58: { + ErrorMessage = input.ReadString(); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + entries_.AddEntriesFrom(ref input, _repeated_entries_codec); + break; + } + case 34: { + ContinuationToken = input.ReadString(); + break; + } + case 40: { + HasMore = input.ReadBool(); + break; + } + case 48: { + Success = input.ReadBool(); + break; + } + case 58: { + ErrorMessage = input.ReadString(); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DebugSnapshotRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DebugSnapshotRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[56]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugSnapshotRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugSnapshotRequestDto(DebugSnapshotRequestDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + correlationId_ = other.correlationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugSnapshotRequestDto Clone() { + return new DebugSnapshotRequestDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 2; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DebugSnapshotRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DebugSnapshotRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (CorrelationId != other.CorrelationId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DebugSnapshotRequestDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SubscribeDebugViewRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SubscribeDebugViewRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[57]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SubscribeDebugViewRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SubscribeDebugViewRequestDto(SubscribeDebugViewRequestDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + correlationId_ = other.correlationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SubscribeDebugViewRequestDto Clone() { + return new SubscribeDebugViewRequestDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 2; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SubscribeDebugViewRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SubscribeDebugViewRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (CorrelationId != other.CorrelationId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SubscribeDebugViewRequestDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UnsubscribeDebugViewRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UnsubscribeDebugViewRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[58]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewRequestDto(UnsubscribeDebugViewRequestDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + correlationId_ = other.correlationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewRequestDto Clone() { + return new UnsubscribeDebugViewRequestDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 2; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UnsubscribeDebugViewRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UnsubscribeDebugViewRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (CorrelationId != other.CorrelationId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(CorrelationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UnsubscribeDebugViewRequestDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + CorrelationId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// UnsubscribeDebugView is a Tell today (CommunicationService.UnsubscribeDebugView + /// fires and forgets). A unary RPC must still answer something, so the site sends + /// this empty ack; the central transport ignores it to keep the caller-visible + /// fire-and-forget semantics identical. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UnsubscribeDebugViewAckDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UnsubscribeDebugViewAckDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[59]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewAckDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewAckDto(UnsubscribeDebugViewAckDto other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UnsubscribeDebugViewAckDto Clone() { + return new UnsubscribeDebugViewAckDto(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UnsubscribeDebugViewAckDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UnsubscribeDebugViewAckDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UnsubscribeDebugViewAckDto other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AlarmConditionStateDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AlarmConditionStateDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[60]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AlarmConditionStateDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AlarmConditionStateDto(AlarmConditionStateDto other) : this() { + active_ = other.active_; + acknowledged_ = other.acknowledged_; + Confirmed = other.Confirmed; + shelve_ = other.shelve_; + suppressed_ = other.suppressed_; + severity_ = other.severity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AlarmConditionStateDto Clone() { + return new AlarmConditionStateDto(this); + } + + /// Field number for the "active" field. + public const int ActiveFieldNumber = 1; + private bool active_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Active { + get { return active_; } + set { + active_ = value; + } + } + + /// Field number for the "acknowledged" field. + public const int AcknowledgedFieldNumber = 2; + private bool acknowledged_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Acknowledged { + get { return acknowledged_; } + set { + acknowledged_ = value; + } + } + + /// Field number for the "confirmed" field. + public const int ConfirmedFieldNumber = 3; + private static readonly pb::FieldCodec _single_confirmed_codec = pb::FieldCodec.ForStructWrapper(26); + private bool? confirmed_; + /// + /// absent => null (not confirmable) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool? Confirmed { + get { return confirmed_; } + set { + confirmed_ = value; + } + } + + + /// Field number for the "shelve" field. + public const int ShelveFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto shelve_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto Shelve { + get { return shelve_; } + set { + shelve_ = value; + } + } + + /// Field number for the "suppressed" field. + public const int SuppressedFieldNumber = 5; + private bool suppressed_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Suppressed { + get { return suppressed_; } + set { + suppressed_ = value; + } + } + + /// Field number for the "severity" field. + public const int SeverityFieldNumber = 6; + private int severity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Severity { + get { return severity_; } + set { + severity_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AlarmConditionStateDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AlarmConditionStateDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Active != other.Active) return false; + if (Acknowledged != other.Acknowledged) return false; + if (Confirmed != other.Confirmed) return false; + if (Shelve != other.Shelve) return false; + if (Suppressed != other.Suppressed) return false; + if (Severity != other.Severity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (Active != false) hash ^= Active.GetHashCode(); + if (Acknowledged != false) hash ^= Acknowledged.GetHashCode(); + if (confirmed_ != null) hash ^= Confirmed.GetHashCode(); + if (Shelve != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified) hash ^= Shelve.GetHashCode(); + if (Suppressed != false) hash ^= Suppressed.GetHashCode(); + if (Severity != 0) hash ^= Severity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Active != false) { + output.WriteRawTag(8); + output.WriteBool(Active); + } + if (Acknowledged != false) { + output.WriteRawTag(16); + output.WriteBool(Acknowledged); + } + if (confirmed_ != null) { + _single_confirmed_codec.WriteTagAndValue(output, Confirmed); + } + if (Shelve != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) Shelve); + } + if (Suppressed != false) { + output.WriteRawTag(40); + output.WriteBool(Suppressed); + } + if (Severity != 0) { + output.WriteRawTag(48); + output.WriteInt32(Severity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Active != false) { + output.WriteRawTag(8); + output.WriteBool(Active); + } + if (Acknowledged != false) { + output.WriteRawTag(16); + output.WriteBool(Acknowledged); + } + if (confirmed_ != null) { + _single_confirmed_codec.WriteTagAndValue(ref output, Confirmed); + } + if (Shelve != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified) { + output.WriteRawTag(32); + output.WriteEnum((int) Shelve); + } + if (Suppressed != false) { + output.WriteRawTag(40); + output.WriteBool(Suppressed); + } + if (Severity != 0) { + output.WriteRawTag(48); + output.WriteInt32(Severity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (Active != false) { + size += 1 + 1; + } + if (Acknowledged != false) { + size += 1 + 1; + } + if (confirmed_ != null) { + size += _single_confirmed_codec.CalculateSizeWithTag(Confirmed); + } + if (Shelve != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Shelve); + } + if (Suppressed != false) { + size += 1 + 1; + } + if (Severity != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Severity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AlarmConditionStateDto other) { + if (other == null) { + return; + } + if (other.Active != false) { + Active = other.Active; + } + if (other.Acknowledged != false) { + Acknowledged = other.Acknowledged; + } + if (other.confirmed_ != null) { + if (confirmed_ == null || other.Confirmed != false) { + Confirmed = other.Confirmed; + } + } + if (other.Shelve != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto.Unspecified) { + Shelve = other.Shelve; + } + if (other.Suppressed != false) { + Suppressed = other.Suppressed; + } + if (other.Severity != 0) { + Severity = other.Severity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Active = input.ReadBool(); + break; + } + case 16: { + Acknowledged = input.ReadBool(); + break; + } + case 26: { + bool? value = _single_confirmed_codec.Read(input); + if (confirmed_ == null || value != false) { + Confirmed = value; + } + break; + } + case 32: { + Shelve = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto) input.ReadEnum(); + break; + } + case 40: { + Suppressed = input.ReadBool(); + break; + } + case 48: { + Severity = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Active = input.ReadBool(); + break; + } + case 16: { + Acknowledged = input.ReadBool(); + break; + } + case 26: { + bool? value = _single_confirmed_codec.Read(ref input); + if (confirmed_ == null || value != false) { + Confirmed = value; + } + break; + } + case 32: { + Shelve = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmShelveStateDto) input.ReadEnum(); + break; + } + case 40: { + Suppressed = input.ReadBool(); + break; + } + case 48: { + Severity = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DebugAttributeValueDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DebugAttributeValueDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[61]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAttributeValueDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAttributeValueDto(DebugAttributeValueDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + attributePath_ = other.attributePath_; + attributeName_ = other.attributeName_; + value_ = other.value_ != null ? other.value_.Clone() : null; + quality_ = other.quality_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAttributeValueDto Clone() { + return new DebugAttributeValueDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_path" field. + public const int AttributePathFieldNumber = 2; + private string attributePath_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AttributePath { + get { return attributePath_; } + set { + attributePath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_name" field. + public const int AttributeNameFieldNumber = 3; + private string attributeName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AttributeName { + get { return attributeName_; } + set { + attributeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue value_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue Value { + get { return value_; } + set { + value_ = value; + } + } + + /// Field number for the "quality" field. + public const int QualityFieldNumber = 5; + private string quality_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Quality { + get { return quality_; } + set { + quality_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DebugAttributeValueDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DebugAttributeValueDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (AttributePath != other.AttributePath) return false; + if (AttributeName != other.AttributeName) return false; + if (!object.Equals(Value, other.Value)) return false; + if (Quality != other.Quality) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (AttributePath.Length != 0) hash ^= AttributePath.GetHashCode(); + if (AttributeName.Length != 0) hash ^= AttributeName.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + if (Quality.Length != 0) hash ^= Quality.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (AttributePath.Length != 0) { + output.WriteRawTag(18); + output.WriteString(AttributePath); + } + if (AttributeName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AttributeName); + } + if (value_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(42); + output.WriteString(Quality); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (AttributePath.Length != 0) { + output.WriteRawTag(18); + output.WriteString(AttributePath); + } + if (AttributeName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AttributeName); + } + if (value_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(42); + output.WriteString(Quality); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (AttributePath.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AttributePath); + } + if (AttributeName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AttributeName); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + if (Quality.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Quality); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DebugAttributeValueDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.AttributePath.Length != 0) { + AttributePath = other.AttributePath; + } + if (other.AttributeName.Length != 0) { + AttributeName = other.AttributeName; + } + if (other.value_ != null) { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + Value.MergeFrom(other.Value); + } + if (other.Quality.Length != 0) { + Quality = other.Quality; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + AttributePath = input.ReadString(); + break; + } + case 26: { + AttributeName = input.ReadString(); + break; + } + case 34: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 42: { + Quality = input.ReadString(); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + AttributePath = input.ReadString(); + break; + } + case 26: { + AttributeName = input.ReadString(); + break; + } + case 34: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 42: { + Quality = input.ReadString(); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + /// + /// Full-fidelity projection of Commons AlarmStateChanged. Deliberately NOT the + /// sitestream AlarmStateUpdate: that one flattens the value to a display string + /// and the shelve state to free text, which is right for a live stream but would + /// lose data on a snapshot the central UI renders as authoritative state. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DebugAlarmStateDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DebugAlarmStateDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[62]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAlarmStateDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAlarmStateDto(DebugAlarmStateDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + alarmName_ = other.alarmName_; + state_ = other.state_; + priority_ = other.priority_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + level_ = other.level_; + message_ = other.message_; + kind_ = other.kind_; + condition_ = other.condition_ != null ? other.condition_.Clone() : null; + sourceReference_ = other.sourceReference_; + alarmTypeName_ = other.alarmTypeName_; + category_ = other.category_; + operatorUser_ = other.operatorUser_; + operatorComment_ = other.operatorComment_; + originalRaiseTime_ = other.originalRaiseTime_ != null ? other.originalRaiseTime_.Clone() : null; + currentValue_ = other.currentValue_; + limitValue_ = other.limitValue_; + nativeSourceCanonicalName_ = other.nativeSourceCanonicalName_; + isConfiguredPlaceholder_ = other.isConfiguredPlaceholder_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugAlarmStateDto Clone() { + return new DebugAlarmStateDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "alarm_name" field. + public const int AlarmNameFieldNumber = 2; + private string alarmName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AlarmName { + get { return alarmName_; } + set { + alarmName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "state" field. + public const int StateFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto state_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto State { + get { return state_; } + set { + state_ = value; + } + } + + /// Field number for the "priority" field. + public const int PriorityFieldNumber = 4; + private int priority_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Priority { + get { return priority_; } + set { + priority_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "level" field. + public const int LevelFieldNumber = 6; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto level_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto Level { + get { return level_; } + set { + level_ = value; + } + } + + /// Field number for the "message" field. + public const int MessageFieldNumber = 7; + private string message_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Message { + get { return message_; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 8; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto kind_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto Kind { + get { return kind_; } + set { + kind_ = value; + } + } + + /// Field number for the "condition" field. + public const int ConditionFieldNumber = 9; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto condition_; + /// + /// Absent means "not explicitly set" — the CLR record then derives the + /// computed default from state + priority. See the mapper's note on why the + /// encoder omits a condition that already equals that derived default. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto Condition { + get { return condition_; } + set { + condition_ = value; + } + } + + /// Field number for the "source_reference" field. + public const int SourceReferenceFieldNumber = 10; + private string sourceReference_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SourceReference { + get { return sourceReference_; } + set { + sourceReference_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "alarm_type_name" field. + public const int AlarmTypeNameFieldNumber = 11; + private string alarmTypeName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AlarmTypeName { + get { return alarmTypeName_; } + set { + alarmTypeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "category" field. + public const int CategoryFieldNumber = 12; + private string category_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Category { + get { return category_; } + set { + category_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "operator_user" field. + public const int OperatorUserFieldNumber = 13; + private string operatorUser_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OperatorUser { + get { return operatorUser_; } + set { + operatorUser_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "operator_comment" field. + public const int OperatorCommentFieldNumber = 14; + private string operatorComment_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OperatorComment { + get { return operatorComment_; } + set { + operatorComment_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "original_raise_time" field. + public const int OriginalRaiseTimeFieldNumber = 15; + private global::Google.Protobuf.WellKnownTypes.Timestamp originalRaiseTime_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp OriginalRaiseTime { + get { return originalRaiseTime_; } + set { + originalRaiseTime_ = value; + } + } + + /// Field number for the "current_value" field. + public const int CurrentValueFieldNumber = 16; + private string currentValue_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CurrentValue { + get { return currentValue_; } + set { + currentValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "limit_value" field. + public const int LimitValueFieldNumber = 17; + private string limitValue_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string LimitValue { + get { return limitValue_; } + set { + limitValue_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "native_source_canonical_name" field. + public const int NativeSourceCanonicalNameFieldNumber = 18; + private string nativeSourceCanonicalName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NativeSourceCanonicalName { + get { return nativeSourceCanonicalName_; } + set { + nativeSourceCanonicalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "is_configured_placeholder" field. + public const int IsConfiguredPlaceholderFieldNumber = 19; + private bool isConfiguredPlaceholder_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool IsConfiguredPlaceholder { + get { return isConfiguredPlaceholder_; } + set { + isConfiguredPlaceholder_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DebugAlarmStateDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DebugAlarmStateDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (AlarmName != other.AlarmName) return false; + if (State != other.State) return false; + if (Priority != other.Priority) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (Level != other.Level) return false; + if (Message != other.Message) return false; + if (Kind != other.Kind) return false; + if (!object.Equals(Condition, other.Condition)) return false; + if (SourceReference != other.SourceReference) return false; + if (AlarmTypeName != other.AlarmTypeName) return false; + if (Category != other.Category) return false; + if (OperatorUser != other.OperatorUser) return false; + if (OperatorComment != other.OperatorComment) return false; + if (!object.Equals(OriginalRaiseTime, other.OriginalRaiseTime)) return false; + if (CurrentValue != other.CurrentValue) return false; + if (LimitValue != other.LimitValue) return false; + if (NativeSourceCanonicalName != other.NativeSourceCanonicalName) return false; + if (IsConfiguredPlaceholder != other.IsConfiguredPlaceholder) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (AlarmName.Length != 0) hash ^= AlarmName.GetHashCode(); + if (State != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified) hash ^= State.GetHashCode(); + if (Priority != 0) hash ^= Priority.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (Level != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified) hash ^= Level.GetHashCode(); + if (Message.Length != 0) hash ^= Message.GetHashCode(); + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified) hash ^= Kind.GetHashCode(); + if (condition_ != null) hash ^= Condition.GetHashCode(); + if (SourceReference.Length != 0) hash ^= SourceReference.GetHashCode(); + if (AlarmTypeName.Length != 0) hash ^= AlarmTypeName.GetHashCode(); + if (Category.Length != 0) hash ^= Category.GetHashCode(); + if (OperatorUser.Length != 0) hash ^= OperatorUser.GetHashCode(); + if (OperatorComment.Length != 0) hash ^= OperatorComment.GetHashCode(); + if (originalRaiseTime_ != null) hash ^= OriginalRaiseTime.GetHashCode(); + if (CurrentValue.Length != 0) hash ^= CurrentValue.GetHashCode(); + if (LimitValue.Length != 0) hash ^= LimitValue.GetHashCode(); + if (NativeSourceCanonicalName.Length != 0) hash ^= NativeSourceCanonicalName.GetHashCode(); + if (IsConfiguredPlaceholder != false) hash ^= IsConfiguredPlaceholder.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (AlarmName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(AlarmName); + } + if (State != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (Priority != 0) { + output.WriteRawTag(32); + output.WriteInt32(Priority); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (Level != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified) { + output.WriteRawTag(48); + output.WriteEnum((int) Level); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); + } + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified) { + output.WriteRawTag(64); + output.WriteEnum((int) Kind); + } + if (condition_ != null) { + output.WriteRawTag(74); + output.WriteMessage(Condition); + } + if (SourceReference.Length != 0) { + output.WriteRawTag(82); + output.WriteString(SourceReference); + } + if (AlarmTypeName.Length != 0) { + output.WriteRawTag(90); + output.WriteString(AlarmTypeName); + } + if (Category.Length != 0) { + output.WriteRawTag(98); + output.WriteString(Category); + } + if (OperatorUser.Length != 0) { + output.WriteRawTag(106); + output.WriteString(OperatorUser); + } + if (OperatorComment.Length != 0) { + output.WriteRawTag(114); + output.WriteString(OperatorComment); + } + if (originalRaiseTime_ != null) { + output.WriteRawTag(122); + output.WriteMessage(OriginalRaiseTime); + } + if (CurrentValue.Length != 0) { + output.WriteRawTag(130, 1); + output.WriteString(CurrentValue); + } + if (LimitValue.Length != 0) { + output.WriteRawTag(138, 1); + output.WriteString(LimitValue); + } + if (NativeSourceCanonicalName.Length != 0) { + output.WriteRawTag(146, 1); + output.WriteString(NativeSourceCanonicalName); + } + if (IsConfiguredPlaceholder != false) { + output.WriteRawTag(152, 1); + output.WriteBool(IsConfiguredPlaceholder); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + if (AlarmName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(AlarmName); + } + if (State != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified) { + output.WriteRawTag(24); + output.WriteEnum((int) State); + } + if (Priority != 0) { + output.WriteRawTag(32); + output.WriteInt32(Priority); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (Level != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified) { + output.WriteRawTag(48); + output.WriteEnum((int) Level); + } + if (Message.Length != 0) { + output.WriteRawTag(58); + output.WriteString(Message); + } + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified) { + output.WriteRawTag(64); + output.WriteEnum((int) Kind); + } + if (condition_ != null) { + output.WriteRawTag(74); + output.WriteMessage(Condition); + } + if (SourceReference.Length != 0) { + output.WriteRawTag(82); + output.WriteString(SourceReference); + } + if (AlarmTypeName.Length != 0) { + output.WriteRawTag(90); + output.WriteString(AlarmTypeName); + } + if (Category.Length != 0) { + output.WriteRawTag(98); + output.WriteString(Category); + } + if (OperatorUser.Length != 0) { + output.WriteRawTag(106); + output.WriteString(OperatorUser); + } + if (OperatorComment.Length != 0) { + output.WriteRawTag(114); + output.WriteString(OperatorComment); + } + if (originalRaiseTime_ != null) { + output.WriteRawTag(122); + output.WriteMessage(OriginalRaiseTime); + } + if (CurrentValue.Length != 0) { + output.WriteRawTag(130, 1); + output.WriteString(CurrentValue); + } + if (LimitValue.Length != 0) { + output.WriteRawTag(138, 1); + output.WriteString(LimitValue); + } + if (NativeSourceCanonicalName.Length != 0) { + output.WriteRawTag(146, 1); + output.WriteString(NativeSourceCanonicalName); + } + if (IsConfiguredPlaceholder != false) { + output.WriteRawTag(152, 1); + output.WriteBool(IsConfiguredPlaceholder); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (AlarmName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AlarmName); + } + if (State != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) State); + } + if (Priority != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Priority); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (Level != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Level); + } + if (Message.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Message); + } + if (Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); + } + if (condition_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Condition); + } + if (SourceReference.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SourceReference); + } + if (AlarmTypeName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AlarmTypeName); + } + if (Category.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Category); + } + if (OperatorUser.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OperatorUser); + } + if (OperatorComment.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OperatorComment); + } + if (originalRaiseTime_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(OriginalRaiseTime); + } + if (CurrentValue.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(CurrentValue); + } + if (LimitValue.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(LimitValue); + } + if (NativeSourceCanonicalName.Length != 0) { + size += 2 + pb::CodedOutputStream.ComputeStringSize(NativeSourceCanonicalName); + } + if (IsConfiguredPlaceholder != false) { + size += 2 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DebugAlarmStateDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.AlarmName.Length != 0) { + AlarmName = other.AlarmName; + } + if (other.State != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto.Unspecified) { + State = other.State; + } + if (other.Priority != 0) { + Priority = other.Priority; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.Level != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto.Unspecified) { + Level = other.Level; + } + if (other.Message.Length != 0) { + Message = other.Message; + } + if (other.Kind != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto.Unspecified) { + Kind = other.Kind; + } + if (other.condition_ != null) { + if (condition_ == null) { + Condition = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto(); + } + Condition.MergeFrom(other.Condition); + } + if (other.SourceReference.Length != 0) { + SourceReference = other.SourceReference; + } + if (other.AlarmTypeName.Length != 0) { + AlarmTypeName = other.AlarmTypeName; + } + if (other.Category.Length != 0) { + Category = other.Category; + } + if (other.OperatorUser.Length != 0) { + OperatorUser = other.OperatorUser; + } + if (other.OperatorComment.Length != 0) { + OperatorComment = other.OperatorComment; + } + if (other.originalRaiseTime_ != null) { + if (originalRaiseTime_ == null) { + OriginalRaiseTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + OriginalRaiseTime.MergeFrom(other.OriginalRaiseTime); + } + if (other.CurrentValue.Length != 0) { + CurrentValue = other.CurrentValue; + } + if (other.LimitValue.Length != 0) { + LimitValue = other.LimitValue; + } + if (other.NativeSourceCanonicalName.Length != 0) { + NativeSourceCanonicalName = other.NativeSourceCanonicalName; + } + if (other.IsConfiguredPlaceholder != false) { + IsConfiguredPlaceholder = other.IsConfiguredPlaceholder; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + AlarmName = input.ReadString(); + break; + } + case 24: { + State = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto) input.ReadEnum(); + break; + } + case 32: { + Priority = input.ReadInt32(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 48: { + Level = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto) input.ReadEnum(); + break; + } + case 58: { + Message = input.ReadString(); + break; + } + case 64: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto) input.ReadEnum(); + break; + } + case 74: { + if (condition_ == null) { + Condition = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto(); + } + input.ReadMessage(Condition); + break; + } + case 82: { + SourceReference = input.ReadString(); + break; + } + case 90: { + AlarmTypeName = input.ReadString(); + break; + } + case 98: { + Category = input.ReadString(); + break; + } + case 106: { + OperatorUser = input.ReadString(); + break; + } + case 114: { + OperatorComment = input.ReadString(); + break; + } + case 122: { + if (originalRaiseTime_ == null) { + OriginalRaiseTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(OriginalRaiseTime); + break; + } + case 130: { + CurrentValue = input.ReadString(); + break; + } + case 138: { + LimitValue = input.ReadString(); + break; + } + case 146: { + NativeSourceCanonicalName = input.ReadString(); + break; + } + case 152: { + IsConfiguredPlaceholder = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + AlarmName = input.ReadString(); + break; + } + case 24: { + State = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmStateDto) input.ReadEnum(); + break; + } + case 32: { + Priority = input.ReadInt32(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 48: { + Level = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmLevelDto) input.ReadEnum(); + break; + } + case 58: { + Message = input.ReadString(); + break; + } + case 64: { + Kind = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmKindDto) input.ReadEnum(); + break; + } + case 74: { + if (condition_ == null) { + Condition = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.AlarmConditionStateDto(); + } + input.ReadMessage(Condition); + break; + } + case 82: { + SourceReference = input.ReadString(); + break; + } + case 90: { + AlarmTypeName = input.ReadString(); + break; + } + case 98: { + Category = input.ReadString(); + break; + } + case 106: { + OperatorUser = input.ReadString(); + break; + } + case 114: { + OperatorComment = input.ReadString(); + break; + } + case 122: { + if (originalRaiseTime_ == null) { + OriginalRaiseTime = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(OriginalRaiseTime); + break; + } + case 130: { + CurrentValue = input.ReadString(); + break; + } + case 138: { + LimitValue = input.ReadString(); + break; + } + case 146: { + NativeSourceCanonicalName = input.ReadString(); + break; + } + case 152: { + IsConfiguredPlaceholder = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DebugViewSnapshotDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DebugViewSnapshotDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[63]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugViewSnapshotDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugViewSnapshotDto(DebugViewSnapshotDto other) : this() { + instanceUniqueName_ = other.instanceUniqueName_; + attributeValues_ = other.attributeValues_.Clone(); + alarmStates_ = other.alarmStates_.Clone(); + snapshotTimestamp_ = other.snapshotTimestamp_ != null ? other.snapshotTimestamp_.Clone() : null; + instanceNotFound_ = other.instanceNotFound_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DebugViewSnapshotDto Clone() { + return new DebugViewSnapshotDto(this); + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 1; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_values" field. + public const int AttributeValuesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_attributeValues_codec + = pb::FieldCodec.ForMessage(18, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAttributeValueDto.Parser); + private readonly pbc::RepeatedField attributeValues_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttributeValues { + get { return attributeValues_; } + } + + /// Field number for the "alarm_states" field. + public const int AlarmStatesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_alarmStates_codec + = pb::FieldCodec.ForMessage(26, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugAlarmStateDto.Parser); + private readonly pbc::RepeatedField alarmStates_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AlarmStates { + get { return alarmStates_; } + } + + /// Field number for the "snapshot_timestamp" field. + public const int SnapshotTimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp snapshotTimestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp SnapshotTimestamp { + get { return snapshotTimestamp_; } + set { + snapshotTimestamp_ = value; + } + } + + /// Field number for the "instance_not_found" field. + public const int InstanceNotFoundFieldNumber = 5; + private bool instanceNotFound_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool InstanceNotFound { + get { return instanceNotFound_; } + set { + instanceNotFound_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DebugViewSnapshotDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DebugViewSnapshotDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if(!attributeValues_.Equals(other.attributeValues_)) return false; + if(!alarmStates_.Equals(other.alarmStates_)) return false; + if (!object.Equals(SnapshotTimestamp, other.SnapshotTimestamp)) return false; + if (InstanceNotFound != other.InstanceNotFound) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + hash ^= attributeValues_.GetHashCode(); + hash ^= alarmStates_.GetHashCode(); + if (snapshotTimestamp_ != null) hash ^= SnapshotTimestamp.GetHashCode(); + if (InstanceNotFound != false) hash ^= InstanceNotFound.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + attributeValues_.WriteTo(output, _repeated_attributeValues_codec); + alarmStates_.WriteTo(output, _repeated_alarmStates_codec); + if (snapshotTimestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(SnapshotTimestamp); + } + if (InstanceNotFound != false) { + output.WriteRawTag(40); + output.WriteBool(InstanceNotFound); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(10); + output.WriteString(InstanceUniqueName); + } + attributeValues_.WriteTo(ref output, _repeated_attributeValues_codec); + alarmStates_.WriteTo(ref output, _repeated_alarmStates_codec); + if (snapshotTimestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(SnapshotTimestamp); + } + if (InstanceNotFound != false) { + output.WriteRawTag(40); + output.WriteBool(InstanceNotFound); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + size += attributeValues_.CalculateSize(_repeated_attributeValues_codec); + size += alarmStates_.CalculateSize(_repeated_alarmStates_codec); + if (snapshotTimestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SnapshotTimestamp); + } + if (InstanceNotFound != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DebugViewSnapshotDto other) { + if (other == null) { + return; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + attributeValues_.Add(other.attributeValues_); + alarmStates_.Add(other.alarmStates_); + if (other.snapshotTimestamp_ != null) { + if (snapshotTimestamp_ == null) { + SnapshotTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + SnapshotTimestamp.MergeFrom(other.SnapshotTimestamp); + } + if (other.InstanceNotFound != false) { + InstanceNotFound = other.InstanceNotFound; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + attributeValues_.AddEntriesFrom(input, _repeated_attributeValues_codec); + break; + } + case 26: { + alarmStates_.AddEntriesFrom(input, _repeated_alarmStates_codec); + break; + } + case 34: { + if (snapshotTimestamp_ == null) { + SnapshotTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(SnapshotTimestamp); + break; + } + case 40: { + InstanceNotFound = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + InstanceUniqueName = input.ReadString(); + break; + } + case 18: { + attributeValues_.AddEntriesFrom(ref input, _repeated_attributeValues_codec); + break; + } + case 26: { + alarmStates_.AddEntriesFrom(ref input, _repeated_alarmStates_codec); + break; + } + case 34: { + if (snapshotTimestamp_ == null) { + SnapshotTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(SnapshotTimestamp); + break; + } + case 40: { + InstanceNotFound = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class QueryRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new QueryRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[64]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryRequest(QueryRequest other) : this() { + switch (other.CommandCase) { + case CommandOneofCase.EventLogQuery: + EventLogQuery = other.EventLogQuery.Clone(); + break; + case CommandOneofCase.DebugSnapshot: + DebugSnapshot = other.DebugSnapshot.Clone(); + break; + case CommandOneofCase.SubscribeDebugView: + SubscribeDebugView = other.SubscribeDebugView.Clone(); + break; + case CommandOneofCase.UnsubscribeDebugView: + UnsubscribeDebugView = other.UnsubscribeDebugView.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryRequest Clone() { + return new QueryRequest(this); + } + + /// Field number for the "event_log_query" field. + public const int EventLogQueryFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto EventLogQuery { + get { return commandCase_ == CommandOneofCase.EventLogQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.EventLogQuery; + } + } + + /// Field number for the "debug_snapshot" field. + public const int DebugSnapshotFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto DebugSnapshot { + get { return commandCase_ == CommandOneofCase.DebugSnapshot ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DebugSnapshot; + } + } + + /// Field number for the "subscribe_debug_view" field. + public const int SubscribeDebugViewFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto SubscribeDebugView { + get { return commandCase_ == CommandOneofCase.SubscribeDebugView ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.SubscribeDebugView; + } + } + + /// Field number for the "unsubscribe_debug_view" field. + public const int UnsubscribeDebugViewFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto UnsubscribeDebugView { + get { return commandCase_ == CommandOneofCase.UnsubscribeDebugView ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.UnsubscribeDebugView; + } + } + + private object command_; + /// Enum of possible cases for the "command" oneof. + public enum CommandOneofCase { + None = 0, + EventLogQuery = 1, + DebugSnapshot = 2, + SubscribeDebugView = 3, + UnsubscribeDebugView = 4, + } + private CommandOneofCase commandCase_ = CommandOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CommandOneofCase CommandCase { + get { return commandCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearCommand() { + commandCase_ = CommandOneofCase.None; + command_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as QueryRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(QueryRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(EventLogQuery, other.EventLogQuery)) return false; + if (!object.Equals(DebugSnapshot, other.DebugSnapshot)) return false; + if (!object.Equals(SubscribeDebugView, other.SubscribeDebugView)) return false; + if (!object.Equals(UnsubscribeDebugView, other.UnsubscribeDebugView)) return false; + if (CommandCase != other.CommandCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (commandCase_ == CommandOneofCase.EventLogQuery) hash ^= EventLogQuery.GetHashCode(); + if (commandCase_ == CommandOneofCase.DebugSnapshot) hash ^= DebugSnapshot.GetHashCode(); + if (commandCase_ == CommandOneofCase.SubscribeDebugView) hash ^= SubscribeDebugView.GetHashCode(); + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) hash ^= UnsubscribeDebugView.GetHashCode(); + hash ^= (int) commandCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (commandCase_ == CommandOneofCase.EventLogQuery) { + output.WriteRawTag(10); + output.WriteMessage(EventLogQuery); + } + if (commandCase_ == CommandOneofCase.DebugSnapshot) { + output.WriteRawTag(18); + output.WriteMessage(DebugSnapshot); + } + if (commandCase_ == CommandOneofCase.SubscribeDebugView) { + output.WriteRawTag(26); + output.WriteMessage(SubscribeDebugView); + } + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) { + output.WriteRawTag(34); + output.WriteMessage(UnsubscribeDebugView); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (commandCase_ == CommandOneofCase.EventLogQuery) { + output.WriteRawTag(10); + output.WriteMessage(EventLogQuery); + } + if (commandCase_ == CommandOneofCase.DebugSnapshot) { + output.WriteRawTag(18); + output.WriteMessage(DebugSnapshot); + } + if (commandCase_ == CommandOneofCase.SubscribeDebugView) { + output.WriteRawTag(26); + output.WriteMessage(SubscribeDebugView); + } + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) { + output.WriteRawTag(34); + output.WriteMessage(UnsubscribeDebugView); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (commandCase_ == CommandOneofCase.EventLogQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EventLogQuery); + } + if (commandCase_ == CommandOneofCase.DebugSnapshot) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DebugSnapshot); + } + if (commandCase_ == CommandOneofCase.SubscribeDebugView) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(SubscribeDebugView); + } + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnsubscribeDebugView); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(QueryRequest other) { + if (other == null) { + return; + } + switch (other.CommandCase) { + case CommandOneofCase.EventLogQuery: + if (EventLogQuery == null) { + EventLogQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto(); + } + EventLogQuery.MergeFrom(other.EventLogQuery); + break; + case CommandOneofCase.DebugSnapshot: + if (DebugSnapshot == null) { + DebugSnapshot = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto(); + } + DebugSnapshot.MergeFrom(other.DebugSnapshot); + break; + case CommandOneofCase.SubscribeDebugView: + if (SubscribeDebugView == null) { + SubscribeDebugView = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto(); + } + SubscribeDebugView.MergeFrom(other.SubscribeDebugView); + break; + case CommandOneofCase.UnsubscribeDebugView: + if (UnsubscribeDebugView == null) { + UnsubscribeDebugView = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto(); + } + UnsubscribeDebugView.MergeFrom(other.UnsubscribeDebugView); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto(); + if (commandCase_ == CommandOneofCase.EventLogQuery) { + subBuilder.MergeFrom(EventLogQuery); + } + input.ReadMessage(subBuilder); + EventLogQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto(); + if (commandCase_ == CommandOneofCase.DebugSnapshot) { + subBuilder.MergeFrom(DebugSnapshot); + } + input.ReadMessage(subBuilder); + DebugSnapshot = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto(); + if (commandCase_ == CommandOneofCase.SubscribeDebugView) { + subBuilder.MergeFrom(SubscribeDebugView); + } + input.ReadMessage(subBuilder); + SubscribeDebugView = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto(); + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) { + subBuilder.MergeFrom(UnsubscribeDebugView); + } + input.ReadMessage(subBuilder); + UnsubscribeDebugView = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryRequestDto(); + if (commandCase_ == CommandOneofCase.EventLogQuery) { + subBuilder.MergeFrom(EventLogQuery); + } + input.ReadMessage(subBuilder); + EventLogQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugSnapshotRequestDto(); + if (commandCase_ == CommandOneofCase.DebugSnapshot) { + subBuilder.MergeFrom(DebugSnapshot); + } + input.ReadMessage(subBuilder); + DebugSnapshot = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SubscribeDebugViewRequestDto(); + if (commandCase_ == CommandOneofCase.SubscribeDebugView) { + subBuilder.MergeFrom(SubscribeDebugView); + } + input.ReadMessage(subBuilder); + SubscribeDebugView = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewRequestDto(); + if (commandCase_ == CommandOneofCase.UnsubscribeDebugView) { + subBuilder.MergeFrom(UnsubscribeDebugView); + } + input.ReadMessage(subBuilder); + UnsubscribeDebugView = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class QueryReply : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new QueryReply()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[65]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryReply() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryReply(QueryReply other) : this() { + switch (other.ReplyCase) { + case ReplyOneofCase.EventLogQuery: + EventLogQuery = other.EventLogQuery.Clone(); + break; + case ReplyOneofCase.DebugViewSnapshot: + DebugViewSnapshot = other.DebugViewSnapshot.Clone(); + break; + case ReplyOneofCase.UnsubscribeDebugView: + UnsubscribeDebugView = other.UnsubscribeDebugView.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public QueryReply Clone() { + return new QueryReply(this); + } + + /// Field number for the "event_log_query" field. + public const int EventLogQueryFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto EventLogQuery { + get { return replyCase_ == ReplyOneofCase.EventLogQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.EventLogQuery; + } + } + + /// Field number for the "debug_view_snapshot" field. + public const int DebugViewSnapshotFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto DebugViewSnapshot { + get { return replyCase_ == ReplyOneofCase.DebugViewSnapshot ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.DebugViewSnapshot; + } + } + + /// Field number for the "unsubscribe_debug_view" field. + public const int UnsubscribeDebugViewFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto UnsubscribeDebugView { + get { return replyCase_ == ReplyOneofCase.UnsubscribeDebugView ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.UnsubscribeDebugView; + } + } + + private object reply_; + /// Enum of possible cases for the "reply" oneof. + public enum ReplyOneofCase { + None = 0, + EventLogQuery = 1, + DebugViewSnapshot = 2, + UnsubscribeDebugView = 3, + } + private ReplyOneofCase replyCase_ = ReplyOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReplyOneofCase ReplyCase { + get { return replyCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReply() { + replyCase_ = ReplyOneofCase.None; + reply_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as QueryReply); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(QueryReply other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(EventLogQuery, other.EventLogQuery)) return false; + if (!object.Equals(DebugViewSnapshot, other.DebugViewSnapshot)) return false; + if (!object.Equals(UnsubscribeDebugView, other.UnsubscribeDebugView)) return false; + if (ReplyCase != other.ReplyCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (replyCase_ == ReplyOneofCase.EventLogQuery) hash ^= EventLogQuery.GetHashCode(); + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) hash ^= DebugViewSnapshot.GetHashCode(); + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) hash ^= UnsubscribeDebugView.GetHashCode(); + hash ^= (int) replyCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (replyCase_ == ReplyOneofCase.EventLogQuery) { + output.WriteRawTag(10); + output.WriteMessage(EventLogQuery); + } + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) { + output.WriteRawTag(18); + output.WriteMessage(DebugViewSnapshot); + } + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) { + output.WriteRawTag(26); + output.WriteMessage(UnsubscribeDebugView); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (replyCase_ == ReplyOneofCase.EventLogQuery) { + output.WriteRawTag(10); + output.WriteMessage(EventLogQuery); + } + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) { + output.WriteRawTag(18); + output.WriteMessage(DebugViewSnapshot); + } + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) { + output.WriteRawTag(26); + output.WriteMessage(UnsubscribeDebugView); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (replyCase_ == ReplyOneofCase.EventLogQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(EventLogQuery); + } + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DebugViewSnapshot); + } + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnsubscribeDebugView); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(QueryReply other) { + if (other == null) { + return; + } + switch (other.ReplyCase) { + case ReplyOneofCase.EventLogQuery: + if (EventLogQuery == null) { + EventLogQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto(); + } + EventLogQuery.MergeFrom(other.EventLogQuery); + break; + case ReplyOneofCase.DebugViewSnapshot: + if (DebugViewSnapshot == null) { + DebugViewSnapshot = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto(); + } + DebugViewSnapshot.MergeFrom(other.DebugViewSnapshot); + break; + case ReplyOneofCase.UnsubscribeDebugView: + if (UnsubscribeDebugView == null) { + UnsubscribeDebugView = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto(); + } + UnsubscribeDebugView.MergeFrom(other.UnsubscribeDebugView); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.EventLogQuery) { + subBuilder.MergeFrom(EventLogQuery); + } + input.ReadMessage(subBuilder); + EventLogQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto(); + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) { + subBuilder.MergeFrom(DebugViewSnapshot); + } + input.ReadMessage(subBuilder); + DebugViewSnapshot = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto(); + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) { + subBuilder.MergeFrom(UnsubscribeDebugView); + } + input.ReadMessage(subBuilder); + UnsubscribeDebugView = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.EventLogQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.EventLogQuery) { + subBuilder.MergeFrom(EventLogQuery); + } + input.ReadMessage(subBuilder); + EventLogQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DebugViewSnapshotDto(); + if (replyCase_ == ReplyOneofCase.DebugViewSnapshot) { + subBuilder.MergeFrom(DebugViewSnapshot); + } + input.ReadMessage(subBuilder); + DebugViewSnapshot = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.UnsubscribeDebugViewAckDto(); + if (replyCase_ == ReplyOneofCase.UnsubscribeDebugView) { + subBuilder.MergeFrom(UnsubscribeDebugView); + } + input.ReadMessage(subBuilder); + UnsubscribeDebugView = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageQueryRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageQueryRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[66]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryRequestDto(ParkedMessageQueryRequestDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + pageNumber_ = other.pageNumber_; + pageSize_ = other.pageSize_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryRequestDto Clone() { + return new ParkedMessageQueryRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "page_number" field. + public const int PageNumberFieldNumber = 3; + private int pageNumber_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageNumber { + get { return pageNumber_; } + set { + pageNumber_ = value; + } + } + + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 4; + private int pageSize_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageSize { + get { return pageSize_; } + set { + pageSize_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageQueryRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageQueryRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if (PageNumber != other.PageNumber) return false; + if (PageSize != other.PageSize) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (PageNumber != 0) hash ^= PageNumber.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (PageNumber != 0) { + output.WriteRawTag(24); + output.WriteInt32(PageNumber); + } + if (PageSize != 0) { + output.WriteRawTag(32); + output.WriteInt32(PageSize); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (PageNumber != 0) { + output.WriteRawTag(24); + output.WriteInt32(PageNumber); + } + if (PageSize != 0) { + output.WriteRawTag(32); + output.WriteInt32(PageSize); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (PageNumber != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageNumber); + } + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageQueryRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + if (other.PageNumber != 0) { + PageNumber = other.PageNumber; + } + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 24: { + PageNumber = input.ReadInt32(); + break; + } + case 32: { + PageSize = input.ReadInt32(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 24: { + PageNumber = input.ReadInt32(); + break; + } + case 32: { + PageSize = input.ReadInt32(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageEntryDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageEntryDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[67]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageEntryDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageEntryDto(ParkedMessageEntryDto other) : this() { + messageId_ = other.messageId_; + targetSystem_ = other.targetSystem_; + methodName_ = other.methodName_; + errorMessage_ = other.errorMessage_; + attemptCount_ = other.attemptCount_; + originalTimestamp_ = other.originalTimestamp_ != null ? other.originalTimestamp_.Clone() : null; + lastAttemptTimestamp_ = other.lastAttemptTimestamp_ != null ? other.lastAttemptTimestamp_.Clone() : null; + maxAttempts_ = other.maxAttempts_; + category_ = other.category_; + originInstance_ = other.originInstance_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageEntryDto Clone() { + return new ParkedMessageEntryDto(this); + } + + /// Field number for the "message_id" field. + public const int MessageIdFieldNumber = 1; + private string messageId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MessageId { + get { return messageId_; } + set { + messageId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_system" field. + public const int TargetSystemFieldNumber = 2; + private string targetSystem_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetSystem { + get { return targetSystem_; } + set { + targetSystem_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "method_name" field. + public const int MethodNameFieldNumber = 3; + private string methodName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MethodName { + get { return methodName_; } + set { + methodName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attempt_count" field. + public const int AttemptCountFieldNumber = 5; + private int attemptCount_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int AttemptCount { + get { return attemptCount_; } + set { + attemptCount_ = value; + } + } + + /// Field number for the "original_timestamp" field. + public const int OriginalTimestampFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp originalTimestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp OriginalTimestamp { + get { return originalTimestamp_; } + set { + originalTimestamp_ = value; + } + } + + /// Field number for the "last_attempt_timestamp" field. + public const int LastAttemptTimestampFieldNumber = 7; + private global::Google.Protobuf.WellKnownTypes.Timestamp lastAttemptTimestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp LastAttemptTimestamp { + get { return lastAttemptTimestamp_; } + set { + lastAttemptTimestamp_ = value; + } + } + + /// Field number for the "max_attempts" field. + public const int MaxAttemptsFieldNumber = 8; + private int maxAttempts_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int MaxAttempts { + get { return maxAttempts_; } + set { + maxAttempts_ = value; + } + } + + /// Field number for the "category" field. + public const int CategoryFieldNumber = 9; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto category_ = global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto Category { + get { return category_; } + set { + category_ = value; + } + } + + /// Field number for the "origin_instance" field. + public const int OriginInstanceFieldNumber = 10; + private string originInstance_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string OriginInstance { + get { return originInstance_; } + set { + originInstance_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageEntryDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageEntryDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (MessageId != other.MessageId) return false; + if (TargetSystem != other.TargetSystem) return false; + if (MethodName != other.MethodName) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (AttemptCount != other.AttemptCount) return false; + if (!object.Equals(OriginalTimestamp, other.OriginalTimestamp)) return false; + if (!object.Equals(LastAttemptTimestamp, other.LastAttemptTimestamp)) return false; + if (MaxAttempts != other.MaxAttempts) return false; + if (Category != other.Category) return false; + if (OriginInstance != other.OriginInstance) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (MessageId.Length != 0) hash ^= MessageId.GetHashCode(); + if (TargetSystem.Length != 0) hash ^= TargetSystem.GetHashCode(); + if (MethodName.Length != 0) hash ^= MethodName.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (AttemptCount != 0) hash ^= AttemptCount.GetHashCode(); + if (originalTimestamp_ != null) hash ^= OriginalTimestamp.GetHashCode(); + if (lastAttemptTimestamp_ != null) hash ^= LastAttemptTimestamp.GetHashCode(); + if (MaxAttempts != 0) hash ^= MaxAttempts.GetHashCode(); + if (Category != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified) hash ^= Category.GetHashCode(); + if (OriginInstance.Length != 0) hash ^= OriginInstance.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (MessageId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(MessageId); + } + if (TargetSystem.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TargetSystem); + } + if (MethodName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MethodName); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (AttemptCount != 0) { + output.WriteRawTag(40); + output.WriteInt32(AttemptCount); + } + if (originalTimestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(OriginalTimestamp); + } + if (lastAttemptTimestamp_ != null) { + output.WriteRawTag(58); + output.WriteMessage(LastAttemptTimestamp); + } + if (MaxAttempts != 0) { + output.WriteRawTag(64); + output.WriteInt32(MaxAttempts); + } + if (Category != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified) { + output.WriteRawTag(72); + output.WriteEnum((int) Category); + } + if (OriginInstance.Length != 0) { + output.WriteRawTag(82); + output.WriteString(OriginInstance); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (MessageId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(MessageId); + } + if (TargetSystem.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TargetSystem); + } + if (MethodName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MethodName); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (AttemptCount != 0) { + output.WriteRawTag(40); + output.WriteInt32(AttemptCount); + } + if (originalTimestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(OriginalTimestamp); + } + if (lastAttemptTimestamp_ != null) { + output.WriteRawTag(58); + output.WriteMessage(LastAttemptTimestamp); + } + if (MaxAttempts != 0) { + output.WriteRawTag(64); + output.WriteInt32(MaxAttempts); + } + if (Category != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified) { + output.WriteRawTag(72); + output.WriteEnum((int) Category); + } + if (OriginInstance.Length != 0) { + output.WriteRawTag(82); + output.WriteString(OriginInstance); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (MessageId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MessageId); + } + if (TargetSystem.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetSystem); + } + if (MethodName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MethodName); + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (AttemptCount != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(AttemptCount); + } + if (originalTimestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(OriginalTimestamp); + } + if (lastAttemptTimestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(LastAttemptTimestamp); + } + if (MaxAttempts != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxAttempts); + } + if (Category != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Category); + } + if (OriginInstance.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(OriginInstance); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageEntryDto other) { + if (other == null) { + return; + } + if (other.MessageId.Length != 0) { + MessageId = other.MessageId; + } + if (other.TargetSystem.Length != 0) { + TargetSystem = other.TargetSystem; + } + if (other.MethodName.Length != 0) { + MethodName = other.MethodName; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.AttemptCount != 0) { + AttemptCount = other.AttemptCount; + } + if (other.originalTimestamp_ != null) { + if (originalTimestamp_ == null) { + OriginalTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + OriginalTimestamp.MergeFrom(other.OriginalTimestamp); + } + if (other.lastAttemptTimestamp_ != null) { + if (lastAttemptTimestamp_ == null) { + LastAttemptTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + LastAttemptTimestamp.MergeFrom(other.LastAttemptTimestamp); + } + if (other.MaxAttempts != 0) { + MaxAttempts = other.MaxAttempts; + } + if (other.Category != global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto.Unspecified) { + Category = other.Category; + } + if (other.OriginInstance.Length != 0) { + OriginInstance = other.OriginInstance; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + MessageId = input.ReadString(); + break; + } + case 18: { + TargetSystem = input.ReadString(); + break; + } + case 26: { + MethodName = input.ReadString(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 40: { + AttemptCount = input.ReadInt32(); + break; + } + case 50: { + if (originalTimestamp_ == null) { + OriginalTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(OriginalTimestamp); + break; + } + case 58: { + if (lastAttemptTimestamp_ == null) { + LastAttemptTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LastAttemptTimestamp); + break; + } + case 64: { + MaxAttempts = input.ReadInt32(); + break; + } + case 72: { + Category = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto) input.ReadEnum(); + break; + } + case 82: { + OriginInstance = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + MessageId = input.ReadString(); + break; + } + case 18: { + TargetSystem = input.ReadString(); + break; + } + case 26: { + MethodName = input.ReadString(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 40: { + AttemptCount = input.ReadInt32(); + break; + } + case 50: { + if (originalTimestamp_ == null) { + OriginalTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(OriginalTimestamp); + break; + } + case 58: { + if (lastAttemptTimestamp_ == null) { + LastAttemptTimestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(LastAttemptTimestamp); + break; + } + case 64: { + MaxAttempts = input.ReadInt32(); + break; + } + case 72: { + Category = (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.StoreAndForwardCategoryDto) input.ReadEnum(); + break; + } + case 82: { + OriginInstance = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageQueryResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageQueryResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[68]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryResponseDto(ParkedMessageQueryResponseDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + messages_ = other.messages_.Clone(); + totalCount_ = other.totalCount_; + pageNumber_ = other.pageNumber_; + pageSize_ = other.pageSize_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageQueryResponseDto Clone() { + return new ParkedMessageQueryResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "messages" field. + public const int MessagesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_messages_codec + = pb::FieldCodec.ForMessage(26, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageEntryDto.Parser); + private readonly pbc::RepeatedField messages_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Messages { + get { return messages_; } + } + + /// Field number for the "total_count" field. + public const int TotalCountFieldNumber = 4; + private int totalCount_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int TotalCount { + get { return totalCount_; } + set { + totalCount_ = value; + } + } + + /// Field number for the "page_number" field. + public const int PageNumberFieldNumber = 5; + private int pageNumber_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageNumber { + get { return pageNumber_; } + set { + pageNumber_ = value; + } + } + + /// Field number for the "page_size" field. + public const int PageSizeFieldNumber = 6; + private int pageSize_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int PageSize { + get { return pageSize_; } + set { + pageSize_ = value; + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 7; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 8; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 9; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageQueryResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageQueryResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if(!messages_.Equals(other.messages_)) return false; + if (TotalCount != other.TotalCount) return false; + if (PageNumber != other.PageNumber) return false; + if (PageSize != other.PageSize) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + hash ^= messages_.GetHashCode(); + if (TotalCount != 0) hash ^= TotalCount.GetHashCode(); + if (PageNumber != 0) hash ^= PageNumber.GetHashCode(); + if (PageSize != 0) hash ^= PageSize.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + messages_.WriteTo(output, _repeated_messages_codec); + if (TotalCount != 0) { + output.WriteRawTag(32); + output.WriteInt32(TotalCount); + } + if (PageNumber != 0) { + output.WriteRawTag(40); + output.WriteInt32(PageNumber); + } + if (PageSize != 0) { + output.WriteRawTag(48); + output.WriteInt32(PageSize); + } + if (Success != false) { + output.WriteRawTag(56); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(66); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(74); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + messages_.WriteTo(ref output, _repeated_messages_codec); + if (TotalCount != 0) { + output.WriteRawTag(32); + output.WriteInt32(TotalCount); + } + if (PageNumber != 0) { + output.WriteRawTag(40); + output.WriteInt32(PageNumber); + } + if (PageSize != 0) { + output.WriteRawTag(48); + output.WriteInt32(PageSize); + } + if (Success != false) { + output.WriteRawTag(56); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(66); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(74); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + size += messages_.CalculateSize(_repeated_messages_codec); + if (TotalCount != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(TotalCount); + } + if (PageNumber != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageNumber); + } + if (PageSize != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PageSize); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageQueryResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + messages_.Add(other.messages_); + if (other.TotalCount != 0) { + TotalCount = other.TotalCount; + } + if (other.PageNumber != 0) { + PageNumber = other.PageNumber; + } + if (other.PageSize != 0) { + PageSize = other.PageSize; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + messages_.AddEntriesFrom(input, _repeated_messages_codec); + break; + } + case 32: { + TotalCount = input.ReadInt32(); + break; + } + case 40: { + PageNumber = input.ReadInt32(); + break; + } + case 48: { + PageSize = input.ReadInt32(); + break; + } + case 56: { + Success = input.ReadBool(); + break; + } + case 66: { + ErrorMessage = input.ReadString(); + break; + } + case 74: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + messages_.AddEntriesFrom(ref input, _repeated_messages_codec); + break; + } + case 32: { + TotalCount = input.ReadInt32(); + break; + } + case 40: { + PageNumber = input.ReadInt32(); + break; + } + case 48: { + PageSize = input.ReadInt32(); + break; + } + case 56: { + Success = input.ReadBool(); + break; + } + case 66: { + ErrorMessage = input.ReadString(); + break; + } + case 74: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageRetryRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageRetryRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[69]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryRequestDto(ParkedMessageRetryRequestDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + messageId_ = other.messageId_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryRequestDto Clone() { + return new ParkedMessageRetryRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "message_id" field. + public const int MessageIdFieldNumber = 3; + private string messageId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MessageId { + get { return messageId_; } + set { + messageId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageRetryRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageRetryRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if (MessageId != other.MessageId) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (MessageId.Length != 0) hash ^= MessageId.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (MessageId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MessageId); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (MessageId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MessageId); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (MessageId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MessageId); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageRetryRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + if (other.MessageId.Length != 0) { + MessageId = other.MessageId; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + MessageId = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + MessageId = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageRetryResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageRetryResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[70]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryResponseDto(ParkedMessageRetryResponseDto other) : this() { + correlationId_ = other.correlationId_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageRetryResponseDto Clone() { + return new ParkedMessageRetryResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 3; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageRetryResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageRetryResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageRetryResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageDiscardRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageDiscardRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[71]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardRequestDto(ParkedMessageDiscardRequestDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + messageId_ = other.messageId_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardRequestDto Clone() { + return new ParkedMessageDiscardRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "message_id" field. + public const int MessageIdFieldNumber = 3; + private string messageId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MessageId { + get { return messageId_; } + set { + messageId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageDiscardRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageDiscardRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + if (MessageId != other.MessageId) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (MessageId.Length != 0) hash ^= MessageId.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (MessageId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MessageId); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (MessageId.Length != 0) { + output.WriteRawTag(26); + output.WriteString(MessageId); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (MessageId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MessageId); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageDiscardRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + if (other.MessageId.Length != 0) { + MessageId = other.MessageId; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + MessageId = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + case 26: { + MessageId = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedMessageDiscardResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedMessageDiscardResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[72]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardResponseDto(ParkedMessageDiscardResponseDto other) : this() { + correlationId_ = other.correlationId_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedMessageDiscardResponseDto Clone() { + return new ParkedMessageDiscardResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 3; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedMessageDiscardResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedMessageDiscardResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedMessageDiscardResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RetryParkedOperationDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RetryParkedOperationDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[73]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RetryParkedOperationDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RetryParkedOperationDto(RetryParkedOperationDto other) : this() { + correlationId_ = other.correlationId_; + trackedOperationId_ = other.trackedOperationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RetryParkedOperationDto Clone() { + return new RetryParkedOperationDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tracked_operation_id" field. + public const int TrackedOperationIdFieldNumber = 2; + private string trackedOperationId_ = ""; + /// + /// TrackedOperationId GUID, "D" format + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TrackedOperationId { + get { return trackedOperationId_; } + set { + trackedOperationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RetryParkedOperationDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RetryParkedOperationDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (TrackedOperationId != other.TrackedOperationId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (TrackedOperationId.Length != 0) hash ^= TrackedOperationId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TrackedOperationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TrackedOperationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TrackedOperationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RetryParkedOperationDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.TrackedOperationId.Length != 0) { + TrackedOperationId = other.TrackedOperationId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + TrackedOperationId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + TrackedOperationId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DiscardParkedOperationDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DiscardParkedOperationDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[74]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DiscardParkedOperationDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DiscardParkedOperationDto(DiscardParkedOperationDto other) : this() { + correlationId_ = other.correlationId_; + trackedOperationId_ = other.trackedOperationId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DiscardParkedOperationDto Clone() { + return new DiscardParkedOperationDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "tracked_operation_id" field. + public const int TrackedOperationIdFieldNumber = 2; + private string trackedOperationId_ = ""; + /// + /// TrackedOperationId GUID, "D" format + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TrackedOperationId { + get { return trackedOperationId_; } + set { + trackedOperationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DiscardParkedOperationDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DiscardParkedOperationDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (TrackedOperationId != other.TrackedOperationId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (TrackedOperationId.Length != 0) hash ^= TrackedOperationId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TrackedOperationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(TrackedOperationId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (TrackedOperationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TrackedOperationId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DiscardParkedOperationDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.TrackedOperationId.Length != 0) { + TrackedOperationId = other.TrackedOperationId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + TrackedOperationId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + TrackedOperationId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedOperationActionAckDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedOperationActionAckDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[75]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedOperationActionAckDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedOperationActionAckDto(ParkedOperationActionAckDto other) : this() { + correlationId_ = other.correlationId_; + applied_ = other.applied_; + errorMessage_ = other.errorMessage_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedOperationActionAckDto Clone() { + return new ParkedOperationActionAckDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "applied" field. + public const int AppliedFieldNumber = 2; + private bool applied_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Applied { + get { return applied_; } + set { + applied_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 3; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedOperationActionAckDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedOperationActionAckDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Applied != other.Applied) return false; + if (ErrorMessage != other.ErrorMessage) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Applied != false) hash ^= Applied.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Applied != false) { + output.WriteRawTag(16); + output.WriteBool(Applied); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Applied != false) { + output.WriteRawTag(16); + output.WriteBool(Applied); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Applied != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedOperationActionAckDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Applied != false) { + Applied = other.Applied; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Applied = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Applied = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[76]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedRequest(ParkedRequest other) : this() { + switch (other.CommandCase) { + case CommandOneofCase.ParkedMessageQuery: + ParkedMessageQuery = other.ParkedMessageQuery.Clone(); + break; + case CommandOneofCase.ParkedMessageRetry: + ParkedMessageRetry = other.ParkedMessageRetry.Clone(); + break; + case CommandOneofCase.ParkedMessageDiscard: + ParkedMessageDiscard = other.ParkedMessageDiscard.Clone(); + break; + case CommandOneofCase.RetryParkedOperation: + RetryParkedOperation = other.RetryParkedOperation.Clone(); + break; + case CommandOneofCase.DiscardParkedOperation: + DiscardParkedOperation = other.DiscardParkedOperation.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedRequest Clone() { + return new ParkedRequest(this); + } + + /// Field number for the "parked_message_query" field. + public const int ParkedMessageQueryFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto ParkedMessageQuery { + get { return commandCase_ == CommandOneofCase.ParkedMessageQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.ParkedMessageQuery; + } + } + + /// Field number for the "parked_message_retry" field. + public const int ParkedMessageRetryFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto ParkedMessageRetry { + get { return commandCase_ == CommandOneofCase.ParkedMessageRetry ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.ParkedMessageRetry; + } + } + + /// Field number for the "parked_message_discard" field. + public const int ParkedMessageDiscardFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto ParkedMessageDiscard { + get { return commandCase_ == CommandOneofCase.ParkedMessageDiscard ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.ParkedMessageDiscard; + } + } + + /// Field number for the "retry_parked_operation" field. + public const int RetryParkedOperationFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto RetryParkedOperation { + get { return commandCase_ == CommandOneofCase.RetryParkedOperation ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RetryParkedOperation; + } + } + + /// Field number for the "discard_parked_operation" field. + public const int DiscardParkedOperationFieldNumber = 5; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto DiscardParkedOperation { + get { return commandCase_ == CommandOneofCase.DiscardParkedOperation ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.DiscardParkedOperation; + } + } + + private object command_; + /// Enum of possible cases for the "command" oneof. + public enum CommandOneofCase { + None = 0, + ParkedMessageQuery = 1, + ParkedMessageRetry = 2, + ParkedMessageDiscard = 3, + RetryParkedOperation = 4, + DiscardParkedOperation = 5, + } + private CommandOneofCase commandCase_ = CommandOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CommandOneofCase CommandCase { + get { return commandCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearCommand() { + commandCase_ = CommandOneofCase.None; + command_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(ParkedMessageQuery, other.ParkedMessageQuery)) return false; + if (!object.Equals(ParkedMessageRetry, other.ParkedMessageRetry)) return false; + if (!object.Equals(ParkedMessageDiscard, other.ParkedMessageDiscard)) return false; + if (!object.Equals(RetryParkedOperation, other.RetryParkedOperation)) return false; + if (!object.Equals(DiscardParkedOperation, other.DiscardParkedOperation)) return false; + if (CommandCase != other.CommandCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) hash ^= ParkedMessageQuery.GetHashCode(); + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) hash ^= ParkedMessageRetry.GetHashCode(); + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) hash ^= ParkedMessageDiscard.GetHashCode(); + if (commandCase_ == CommandOneofCase.RetryParkedOperation) hash ^= RetryParkedOperation.GetHashCode(); + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) hash ^= DiscardParkedOperation.GetHashCode(); + hash ^= (int) commandCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) { + output.WriteRawTag(10); + output.WriteMessage(ParkedMessageQuery); + } + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) { + output.WriteRawTag(18); + output.WriteMessage(ParkedMessageRetry); + } + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) { + output.WriteRawTag(26); + output.WriteMessage(ParkedMessageDiscard); + } + if (commandCase_ == CommandOneofCase.RetryParkedOperation) { + output.WriteRawTag(34); + output.WriteMessage(RetryParkedOperation); + } + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) { + output.WriteRawTag(42); + output.WriteMessage(DiscardParkedOperation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) { + output.WriteRawTag(10); + output.WriteMessage(ParkedMessageQuery); + } + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) { + output.WriteRawTag(18); + output.WriteMessage(ParkedMessageRetry); + } + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) { + output.WriteRawTag(26); + output.WriteMessage(ParkedMessageDiscard); + } + if (commandCase_ == CommandOneofCase.RetryParkedOperation) { + output.WriteRawTag(34); + output.WriteMessage(RetryParkedOperation); + } + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) { + output.WriteRawTag(42); + output.WriteMessage(DiscardParkedOperation); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageQuery); + } + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageRetry); + } + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageDiscard); + } + if (commandCase_ == CommandOneofCase.RetryParkedOperation) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RetryParkedOperation); + } + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(DiscardParkedOperation); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedRequest other) { + if (other == null) { + return; + } + switch (other.CommandCase) { + case CommandOneofCase.ParkedMessageQuery: + if (ParkedMessageQuery == null) { + ParkedMessageQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto(); + } + ParkedMessageQuery.MergeFrom(other.ParkedMessageQuery); + break; + case CommandOneofCase.ParkedMessageRetry: + if (ParkedMessageRetry == null) { + ParkedMessageRetry = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto(); + } + ParkedMessageRetry.MergeFrom(other.ParkedMessageRetry); + break; + case CommandOneofCase.ParkedMessageDiscard: + if (ParkedMessageDiscard == null) { + ParkedMessageDiscard = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto(); + } + ParkedMessageDiscard.MergeFrom(other.ParkedMessageDiscard); + break; + case CommandOneofCase.RetryParkedOperation: + if (RetryParkedOperation == null) { + RetryParkedOperation = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto(); + } + RetryParkedOperation.MergeFrom(other.RetryParkedOperation); + break; + case CommandOneofCase.DiscardParkedOperation: + if (DiscardParkedOperation == null) { + DiscardParkedOperation = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto(); + } + DiscardParkedOperation.MergeFrom(other.DiscardParkedOperation); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) { + subBuilder.MergeFrom(ParkedMessageQuery); + } + input.ReadMessage(subBuilder); + ParkedMessageQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) { + subBuilder.MergeFrom(ParkedMessageRetry); + } + input.ReadMessage(subBuilder); + ParkedMessageRetry = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) { + subBuilder.MergeFrom(ParkedMessageDiscard); + } + input.ReadMessage(subBuilder); + ParkedMessageDiscard = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto(); + if (commandCase_ == CommandOneofCase.RetryParkedOperation) { + subBuilder.MergeFrom(RetryParkedOperation); + } + input.ReadMessage(subBuilder); + RetryParkedOperation = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto(); + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) { + subBuilder.MergeFrom(DiscardParkedOperation); + } + input.ReadMessage(subBuilder); + DiscardParkedOperation = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageQuery) { + subBuilder.MergeFrom(ParkedMessageQuery); + } + input.ReadMessage(subBuilder); + ParkedMessageQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageRetry) { + subBuilder.MergeFrom(ParkedMessageRetry); + } + input.ReadMessage(subBuilder); + ParkedMessageRetry = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardRequestDto(); + if (commandCase_ == CommandOneofCase.ParkedMessageDiscard) { + subBuilder.MergeFrom(ParkedMessageDiscard); + } + input.ReadMessage(subBuilder); + ParkedMessageDiscard = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RetryParkedOperationDto(); + if (commandCase_ == CommandOneofCase.RetryParkedOperation) { + subBuilder.MergeFrom(RetryParkedOperation); + } + input.ReadMessage(subBuilder); + RetryParkedOperation = subBuilder; + break; + } + case 42: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.DiscardParkedOperationDto(); + if (commandCase_ == CommandOneofCase.DiscardParkedOperation) { + subBuilder.MergeFrom(DiscardParkedOperation); + } + input.ReadMessage(subBuilder); + DiscardParkedOperation = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParkedReply : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParkedReply()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[77]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedReply() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedReply(ParkedReply other) : this() { + switch (other.ReplyCase) { + case ReplyOneofCase.ParkedMessageQuery: + ParkedMessageQuery = other.ParkedMessageQuery.Clone(); + break; + case ReplyOneofCase.ParkedMessageRetry: + ParkedMessageRetry = other.ParkedMessageRetry.Clone(); + break; + case ReplyOneofCase.ParkedMessageDiscard: + ParkedMessageDiscard = other.ParkedMessageDiscard.Clone(); + break; + case ReplyOneofCase.ParkedOperationAction: + ParkedOperationAction = other.ParkedOperationAction.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParkedReply Clone() { + return new ParkedReply(this); + } + + /// Field number for the "parked_message_query" field. + public const int ParkedMessageQueryFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto ParkedMessageQuery { + get { return replyCase_ == ReplyOneofCase.ParkedMessageQuery ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ParkedMessageQuery; + } + } + + /// Field number for the "parked_message_retry" field. + public const int ParkedMessageRetryFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto ParkedMessageRetry { + get { return replyCase_ == ReplyOneofCase.ParkedMessageRetry ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ParkedMessageRetry; + } + } + + /// Field number for the "parked_message_discard" field. + public const int ParkedMessageDiscardFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto ParkedMessageDiscard { + get { return replyCase_ == ReplyOneofCase.ParkedMessageDiscard ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ParkedMessageDiscard; + } + } + + /// Field number for the "parked_operation_action" field. + public const int ParkedOperationActionFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto ParkedOperationAction { + get { return replyCase_ == ReplyOneofCase.ParkedOperationAction ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.ParkedOperationAction; + } + } + + private object reply_; + /// Enum of possible cases for the "reply" oneof. + public enum ReplyOneofCase { + None = 0, + ParkedMessageQuery = 1, + ParkedMessageRetry = 2, + ParkedMessageDiscard = 3, + ParkedOperationAction = 4, + } + private ReplyOneofCase replyCase_ = ReplyOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReplyOneofCase ReplyCase { + get { return replyCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReply() { + replyCase_ = ReplyOneofCase.None; + reply_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParkedReply); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParkedReply other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(ParkedMessageQuery, other.ParkedMessageQuery)) return false; + if (!object.Equals(ParkedMessageRetry, other.ParkedMessageRetry)) return false; + if (!object.Equals(ParkedMessageDiscard, other.ParkedMessageDiscard)) return false; + if (!object.Equals(ParkedOperationAction, other.ParkedOperationAction)) return false; + if (ReplyCase != other.ReplyCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) hash ^= ParkedMessageQuery.GetHashCode(); + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) hash ^= ParkedMessageRetry.GetHashCode(); + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) hash ^= ParkedMessageDiscard.GetHashCode(); + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) hash ^= ParkedOperationAction.GetHashCode(); + hash ^= (int) replyCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) { + output.WriteRawTag(10); + output.WriteMessage(ParkedMessageQuery); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) { + output.WriteRawTag(18); + output.WriteMessage(ParkedMessageRetry); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) { + output.WriteRawTag(26); + output.WriteMessage(ParkedMessageDiscard); + } + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) { + output.WriteRawTag(34); + output.WriteMessage(ParkedOperationAction); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) { + output.WriteRawTag(10); + output.WriteMessage(ParkedMessageQuery); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) { + output.WriteRawTag(18); + output.WriteMessage(ParkedMessageRetry); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) { + output.WriteRawTag(26); + output.WriteMessage(ParkedMessageDiscard); + } + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) { + output.WriteRawTag(34); + output.WriteMessage(ParkedOperationAction); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageQuery); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageRetry); + } + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedMessageDiscard); + } + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParkedOperationAction); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParkedReply other) { + if (other == null) { + return; + } + switch (other.ReplyCase) { + case ReplyOneofCase.ParkedMessageQuery: + if (ParkedMessageQuery == null) { + ParkedMessageQuery = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto(); + } + ParkedMessageQuery.MergeFrom(other.ParkedMessageQuery); + break; + case ReplyOneofCase.ParkedMessageRetry: + if (ParkedMessageRetry == null) { + ParkedMessageRetry = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto(); + } + ParkedMessageRetry.MergeFrom(other.ParkedMessageRetry); + break; + case ReplyOneofCase.ParkedMessageDiscard: + if (ParkedMessageDiscard == null) { + ParkedMessageDiscard = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto(); + } + ParkedMessageDiscard.MergeFrom(other.ParkedMessageDiscard); + break; + case ReplyOneofCase.ParkedOperationAction: + if (ParkedOperationAction == null) { + ParkedOperationAction = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto(); + } + ParkedOperationAction.MergeFrom(other.ParkedOperationAction); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) { + subBuilder.MergeFrom(ParkedMessageQuery); + } + input.ReadMessage(subBuilder); + ParkedMessageQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) { + subBuilder.MergeFrom(ParkedMessageRetry); + } + input.ReadMessage(subBuilder); + ParkedMessageRetry = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) { + subBuilder.MergeFrom(ParkedMessageDiscard); + } + input.ReadMessage(subBuilder); + ParkedMessageDiscard = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto(); + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) { + subBuilder.MergeFrom(ParkedOperationAction); + } + input.ReadMessage(subBuilder); + ParkedOperationAction = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageQueryResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageQuery) { + subBuilder.MergeFrom(ParkedMessageQuery); + } + input.ReadMessage(subBuilder); + ParkedMessageQuery = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageRetryResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageRetry) { + subBuilder.MergeFrom(ParkedMessageRetry); + } + input.ReadMessage(subBuilder); + ParkedMessageRetry = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedMessageDiscardResponseDto(); + if (replyCase_ == ReplyOneofCase.ParkedMessageDiscard) { + subBuilder.MergeFrom(ParkedMessageDiscard); + } + input.ReadMessage(subBuilder); + ParkedMessageDiscard = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedOperationActionAckDto(); + if (replyCase_ == ReplyOneofCase.ParkedOperationAction) { + subBuilder.MergeFrom(ParkedOperationAction); + } + input.ReadMessage(subBuilder); + ParkedOperationAction = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToCallRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToCallRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[78]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallRequestDto(RouteToCallRequestDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + scriptName_ = other.scriptName_; + parameters_ = other.parameters_ != null ? other.parameters_.Clone() : null; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + parentExecutionId_ = other.parentExecutionId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallRequestDto Clone() { + return new RouteToCallRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "script_name" field. + public const int ScriptNameFieldNumber = 3; + private string scriptName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ScriptName { + get { return scriptName_; } + set { + scriptName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "parameters" field. + public const int ParametersFieldNumber = 4; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap parameters_; + /// + /// absent => null (distinct from empty) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap Parameters { + get { return parameters_; } + set { + parameters_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "parent_execution_id" field. + public const int ParentExecutionIdFieldNumber = 6; + private string parentExecutionId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParentExecutionId { + get { return parentExecutionId_; } + set { + parentExecutionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToCallRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToCallRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (ScriptName != other.ScriptName) return false; + if (!object.Equals(Parameters, other.Parameters)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (ParentExecutionId != other.ParentExecutionId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (ScriptName.Length != 0) hash ^= ScriptName.GetHashCode(); + if (parameters_ != null) hash ^= Parameters.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (ParentExecutionId.Length != 0) hash ^= ParentExecutionId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (ScriptName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ScriptName); + } + if (parameters_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Parameters); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (ScriptName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ScriptName); + } + if (parameters_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Parameters); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(50); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (ScriptName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ScriptName); + } + if (parameters_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Parameters); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (ParentExecutionId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParentExecutionId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToCallRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.ScriptName.Length != 0) { + ScriptName = other.ScriptName; + } + if (other.parameters_ != null) { + if (parameters_ == null) { + Parameters = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + Parameters.MergeFrom(other.Parameters); + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.ParentExecutionId.Length != 0) { + ParentExecutionId = other.ParentExecutionId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + ScriptName = input.ReadString(); + break; + } + case 34: { + if (parameters_ == null) { + Parameters = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + input.ReadMessage(Parameters); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + ScriptName = input.ReadString(); + break; + } + case 34: { + if (parameters_ == null) { + Parameters = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + input.ReadMessage(Parameters); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 50: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToCallResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToCallResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[79]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallResponseDto(RouteToCallResponseDto other) : this() { + correlationId_ = other.correlationId_; + success_ = other.success_; + returnValue_ = other.returnValue_ != null ? other.returnValue_.Clone() : null; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToCallResponseDto Clone() { + return new RouteToCallResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "return_value" field. + public const int ReturnValueFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue returnValue_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue ReturnValue { + get { return returnValue_; } + set { + returnValue_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToCallResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToCallResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Success != other.Success) return false; + if (!object.Equals(ReturnValue, other.ReturnValue)) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (returnValue_ != null) hash ^= ReturnValue.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (returnValue_ != null) { + output.WriteRawTag(26); + output.WriteMessage(ReturnValue); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (returnValue_ != null) { + output.WriteRawTag(26); + output.WriteMessage(ReturnValue); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Success != false) { + size += 1 + 1; + } + if (returnValue_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ReturnValue); + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToCallResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.returnValue_ != null) { + if (returnValue_ == null) { + ReturnValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + ReturnValue.MergeFrom(other.ReturnValue); + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + if (returnValue_ == null) { + ReturnValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(ReturnValue); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + if (returnValue_ == null) { + ReturnValue = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(ReturnValue); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToGetAttributesRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToGetAttributesRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[80]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesRequestDto(RouteToGetAttributesRequestDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + attributeNames_ = other.attributeNames_.Clone(); + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + parentExecutionId_ = other.parentExecutionId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesRequestDto Clone() { + return new RouteToGetAttributesRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_names" field. + public const int AttributeNamesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_attributeNames_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField attributeNames_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttributeNames { + get { return attributeNames_; } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "parent_execution_id" field. + public const int ParentExecutionIdFieldNumber = 5; + private string parentExecutionId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParentExecutionId { + get { return parentExecutionId_; } + set { + parentExecutionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToGetAttributesRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToGetAttributesRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if(!attributeNames_.Equals(other.attributeNames_)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (ParentExecutionId != other.ParentExecutionId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + hash ^= attributeNames_.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (ParentExecutionId.Length != 0) hash ^= ParentExecutionId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + attributeNames_.WriteTo(output, _repeated_attributeNames_codec); + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + attributeNames_.WriteTo(ref output, _repeated_attributeNames_codec); + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + size += attributeNames_.CalculateSize(_repeated_attributeNames_codec); + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (ParentExecutionId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParentExecutionId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToGetAttributesRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + attributeNames_.Add(other.attributeNames_); + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.ParentExecutionId.Length != 0) { + ParentExecutionId = other.ParentExecutionId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + attributeNames_.AddEntriesFrom(input, _repeated_attributeNames_codec); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 42: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + attributeNames_.AddEntriesFrom(ref input, _repeated_attributeNames_codec); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 42: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToGetAttributesResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToGetAttributesResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[81]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesResponseDto(RouteToGetAttributesResponseDto other) : this() { + correlationId_ = other.correlationId_; + values_ = other.values_ != null ? other.values_.Clone() : null; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToGetAttributesResponseDto Clone() { + return new RouteToGetAttributesResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "values" field. + public const int ValuesFieldNumber = 2; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap values_; + /// + /// non-nullable on the CLR side; absent => empty + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap Values { + get { return values_; } + set { + values_ = value; + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 3; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToGetAttributesResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToGetAttributesResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (!object.Equals(Values, other.Values)) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (values_ != null) hash ^= Values.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (values_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Values); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (values_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Values); + } + if (Success != false) { + output.WriteRawTag(24); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (values_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Values); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToGetAttributesResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.values_ != null) { + if (values_ == null) { + Values = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + Values.MergeFrom(other.Values); + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + if (values_ == null) { + Values = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + input.ReadMessage(Values); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + if (values_ == null) { + Values = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValueMap(); + } + input.ReadMessage(Values); + break; + } + case 24: { + Success = input.ReadBool(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + case 42: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToSetAttributesRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToSetAttributesRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[82]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesRequestDto(RouteToSetAttributesRequestDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + attributeValues_ = other.attributeValues_.Clone(); + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + parentExecutionId_ = other.parentExecutionId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesRequestDto Clone() { + return new RouteToSetAttributesRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_values" field. + public const int AttributeValuesFieldNumber = 3; + private static readonly pbc::MapField.Codec _map_attributeValues_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 26); + private readonly pbc::MapField attributeValues_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField AttributeValues { + get { return attributeValues_; } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "parent_execution_id" field. + public const int ParentExecutionIdFieldNumber = 5; + private string parentExecutionId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParentExecutionId { + get { return parentExecutionId_; } + set { + parentExecutionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToSetAttributesRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToSetAttributesRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (!AttributeValues.Equals(other.AttributeValues)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (ParentExecutionId != other.ParentExecutionId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + hash ^= AttributeValues.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (ParentExecutionId.Length != 0) hash ^= ParentExecutionId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + attributeValues_.WriteTo(output, _map_attributeValues_codec); + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + attributeValues_.WriteTo(ref output, _map_attributeValues_codec); + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(42); + output.WriteString(ParentExecutionId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + size += attributeValues_.CalculateSize(_map_attributeValues_codec); + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (ParentExecutionId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParentExecutionId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToSetAttributesRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + attributeValues_.MergeFrom(other.attributeValues_); + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.ParentExecutionId.Length != 0) { + ParentExecutionId = other.ParentExecutionId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + attributeValues_.AddEntriesFrom(input, _map_attributeValues_codec); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 42: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + attributeValues_.AddEntriesFrom(ref input, _map_attributeValues_codec); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 42: { + ParentExecutionId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToSetAttributesResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToSetAttributesResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[83]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesResponseDto(RouteToSetAttributesResponseDto other) : this() { + correlationId_ = other.correlationId_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToSetAttributesResponseDto Clone() { + return new RouteToSetAttributesResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 2; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 3; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 4; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToSetAttributesResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToSetAttributesResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Success != false) { + output.WriteRawTag(16); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(26); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(34); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToSetAttributesResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Success = input.ReadBool(); + break; + } + case 26: { + ErrorMessage = input.ReadString(); + break; + } + case 34: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToWaitForAttributeRequestDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToWaitForAttributeRequestDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[84]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeRequestDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeRequestDto(RouteToWaitForAttributeRequestDto other) : this() { + correlationId_ = other.correlationId_; + instanceUniqueName_ = other.instanceUniqueName_; + attributeName_ = other.attributeName_; + TargetValueEncoded = other.TargetValueEncoded; + timeout_ = other.timeout_ != null ? other.timeout_.Clone() : null; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + parentExecutionId_ = other.parentExecutionId_; + requireGoodQuality_ = other.requireGoodQuality_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeRequestDto Clone() { + return new RouteToWaitForAttributeRequestDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "instance_unique_name" field. + public const int InstanceUniqueNameFieldNumber = 2; + private string instanceUniqueName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string InstanceUniqueName { + get { return instanceUniqueName_; } + set { + instanceUniqueName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "attribute_name" field. + public const int AttributeNameFieldNumber = 3; + private string attributeName_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AttributeName { + get { return attributeName_; } + set { + attributeName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "target_value_encoded" field. + public const int TargetValueEncodedFieldNumber = 4; + private static readonly pb::FieldCodec _single_targetValueEncoded_codec = pb::FieldCodec.ForClassWrapper(34); + private string targetValueEncoded_; + /// + /// NOT the empty-string-means-null convention: "wait for this attribute to + /// become the empty string" is a legitimate target that must stay distinct + /// from "no target supplied", so this one nullable string rides a wrapper. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetValueEncoded { + get { return targetValueEncoded_; } + set { + targetValueEncoded_ = value; + } + } + + + /// Field number for the "timeout" field. + public const int TimeoutFieldNumber = 5; + private global::Google.Protobuf.WellKnownTypes.Duration timeout_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Duration Timeout { + get { return timeout_; } + set { + timeout_ = value; + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 6; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + /// Field number for the "parent_execution_id" field. + public const int ParentExecutionIdFieldNumber = 7; + private string parentExecutionId_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParentExecutionId { + get { return parentExecutionId_; } + set { + parentExecutionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "require_good_quality" field. + public const int RequireGoodQualityFieldNumber = 8; + private bool requireGoodQuality_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool RequireGoodQuality { + get { return requireGoodQuality_; } + set { + requireGoodQuality_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToWaitForAttributeRequestDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToWaitForAttributeRequestDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (InstanceUniqueName != other.InstanceUniqueName) return false; + if (AttributeName != other.AttributeName) return false; + if (TargetValueEncoded != other.TargetValueEncoded) return false; + if (!object.Equals(Timeout, other.Timeout)) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + if (ParentExecutionId != other.ParentExecutionId) return false; + if (RequireGoodQuality != other.RequireGoodQuality) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (InstanceUniqueName.Length != 0) hash ^= InstanceUniqueName.GetHashCode(); + if (AttributeName.Length != 0) hash ^= AttributeName.GetHashCode(); + if (targetValueEncoded_ != null) hash ^= TargetValueEncoded.GetHashCode(); + if (timeout_ != null) hash ^= Timeout.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (ParentExecutionId.Length != 0) hash ^= ParentExecutionId.GetHashCode(); + if (RequireGoodQuality != false) hash ^= RequireGoodQuality.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (AttributeName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AttributeName); + } + if (targetValueEncoded_ != null) { + _single_targetValueEncoded_codec.WriteTagAndValue(output, TargetValueEncoded); + } + if (timeout_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timeout); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ParentExecutionId); + } + if (RequireGoodQuality != false) { + output.WriteRawTag(64); + output.WriteBool(RequireGoodQuality); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + output.WriteRawTag(18); + output.WriteString(InstanceUniqueName); + } + if (AttributeName.Length != 0) { + output.WriteRawTag(26); + output.WriteString(AttributeName); + } + if (targetValueEncoded_ != null) { + _single_targetValueEncoded_codec.WriteTagAndValue(ref output, TargetValueEncoded); + } + if (timeout_ != null) { + output.WriteRawTag(42); + output.WriteMessage(Timeout); + } + if (timestamp_ != null) { + output.WriteRawTag(50); + output.WriteMessage(Timestamp); + } + if (ParentExecutionId.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ParentExecutionId); + } + if (RequireGoodQuality != false) { + output.WriteRawTag(64); + output.WriteBool(RequireGoodQuality); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (InstanceUniqueName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(InstanceUniqueName); + } + if (AttributeName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AttributeName); + } + if (targetValueEncoded_ != null) { + size += _single_targetValueEncoded_codec.CalculateSizeWithTag(TargetValueEncoded); + } + if (timeout_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timeout); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (ParentExecutionId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParentExecutionId); + } + if (RequireGoodQuality != false) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToWaitForAttributeRequestDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.InstanceUniqueName.Length != 0) { + InstanceUniqueName = other.InstanceUniqueName; + } + if (other.AttributeName.Length != 0) { + AttributeName = other.AttributeName; + } + if (other.targetValueEncoded_ != null) { + if (targetValueEncoded_ == null || other.TargetValueEncoded != "") { + TargetValueEncoded = other.TargetValueEncoded; + } + } + if (other.timeout_ != null) { + if (timeout_ == null) { + Timeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + Timeout.MergeFrom(other.Timeout); + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + if (other.ParentExecutionId.Length != 0) { + ParentExecutionId = other.ParentExecutionId; + } + if (other.RequireGoodQuality != false) { + RequireGoodQuality = other.RequireGoodQuality; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + AttributeName = input.ReadString(); + break; + } + case 34: { + string value = _single_targetValueEncoded_codec.Read(input); + if (targetValueEncoded_ == null || value != "") { + TargetValueEncoded = value; + } + break; + } + case 42: { + if (timeout_ == null) { + Timeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(Timeout); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 58: { + ParentExecutionId = input.ReadString(); + break; + } + case 64: { + RequireGoodQuality = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + InstanceUniqueName = input.ReadString(); + break; + } + case 26: { + AttributeName = input.ReadString(); + break; + } + case 34: { + string value = _single_targetValueEncoded_codec.Read(ref input); + if (targetValueEncoded_ == null || value != "") { + TargetValueEncoded = value; + } + break; + } + case 42: { + if (timeout_ == null) { + Timeout = new global::Google.Protobuf.WellKnownTypes.Duration(); + } + input.ReadMessage(Timeout); + break; + } + case 50: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + case 58: { + ParentExecutionId = input.ReadString(); + break; + } + case 64: { + RequireGoodQuality = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteToWaitForAttributeResponseDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteToWaitForAttributeResponseDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[85]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeResponseDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeResponseDto(RouteToWaitForAttributeResponseDto other) : this() { + correlationId_ = other.correlationId_; + matched_ = other.matched_; + value_ = other.value_ != null ? other.value_.Clone() : null; + quality_ = other.quality_; + timedOut_ = other.timedOut_; + success_ = other.success_; + errorMessage_ = other.errorMessage_; + timestamp_ = other.timestamp_ != null ? other.timestamp_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteToWaitForAttributeResponseDto Clone() { + return new RouteToWaitForAttributeResponseDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "matched" field. + public const int MatchedFieldNumber = 2; + private bool matched_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Matched { + get { return matched_; } + set { + matched_ = value; + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 3; + private global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue value_; + /// + /// absent => null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue Value { + get { return value_; } + set { + value_ = value; + } + } + + /// Field number for the "quality" field. + public const int QualityFieldNumber = 4; + private string quality_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Quality { + get { return quality_; } + set { + quality_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timed_out" field. + public const int TimedOutFieldNumber = 5; + private bool timedOut_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool TimedOut { + get { return timedOut_; } + set { + timedOut_ = value; + } + } + + /// Field number for the "success" field. + public const int SuccessFieldNumber = 6; + private bool success_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Success { + get { return success_; } + set { + success_ = value; + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 7; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 8; + private global::Google.Protobuf.WellKnownTypes.Timestamp timestamp_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::Google.Protobuf.WellKnownTypes.Timestamp Timestamp { + get { return timestamp_; } + set { + timestamp_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteToWaitForAttributeResponseDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteToWaitForAttributeResponseDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Matched != other.Matched) return false; + if (!object.Equals(Value, other.Value)) return false; + if (Quality != other.Quality) return false; + if (TimedOut != other.TimedOut) return false; + if (Success != other.Success) return false; + if (ErrorMessage != other.ErrorMessage) return false; + if (!object.Equals(Timestamp, other.Timestamp)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Matched != false) hash ^= Matched.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + if (Quality.Length != 0) hash ^= Quality.GetHashCode(); + if (TimedOut != false) hash ^= TimedOut.GetHashCode(); + if (Success != false) hash ^= Success.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (timestamp_ != null) hash ^= Timestamp.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Matched != false) { + output.WriteRawTag(16); + output.WriteBool(Matched); + } + if (value_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Quality); + } + if (TimedOut != false) { + output.WriteRawTag(40); + output.WriteBool(TimedOut); + } + if (Success != false) { + output.WriteRawTag(48); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Matched != false) { + output.WriteRawTag(16); + output.WriteBool(Matched); + } + if (value_ != null) { + output.WriteRawTag(26); + output.WriteMessage(Value); + } + if (Quality.Length != 0) { + output.WriteRawTag(34); + output.WriteString(Quality); + } + if (TimedOut != false) { + output.WriteRawTag(40); + output.WriteBool(TimedOut); + } + if (Success != false) { + output.WriteRawTag(48); + output.WriteBool(Success); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(58); + output.WriteString(ErrorMessage); + } + if (timestamp_ != null) { + output.WriteRawTag(66); + output.WriteMessage(Timestamp); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Matched != false) { + size += 1 + 1; + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + if (Quality.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Quality); + } + if (TimedOut != false) { + size += 1 + 1; + } + if (Success != false) { + size += 1 + 1; + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (timestamp_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Timestamp); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteToWaitForAttributeResponseDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Matched != false) { + Matched = other.Matched; + } + if (other.value_ != null) { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + Value.MergeFrom(other.Value); + } + if (other.Quality.Length != 0) { + Quality = other.Quality; + } + if (other.TimedOut != false) { + TimedOut = other.TimedOut; + } + if (other.Success != false) { + Success = other.Success; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + if (other.timestamp_ != null) { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + Timestamp.MergeFrom(other.Timestamp); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Matched = input.ReadBool(); + break; + } + case 26: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 34: { + Quality = input.ReadString(); + break; + } + case 40: { + TimedOut = input.ReadBool(); + break; + } + case 48: { + Success = input.ReadBool(); + break; + } + case 58: { + ErrorMessage = input.ReadString(); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Matched = input.ReadBool(); + break; + } + case 26: { + if (value_ == null) { + Value = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LooseValue(); + } + input.ReadMessage(Value); + break; + } + case 34: { + Quality = input.ReadString(); + break; + } + case 40: { + TimedOut = input.ReadBool(); + break; + } + case 48: { + Success = input.ReadBool(); + break; + } + case 58: { + ErrorMessage = input.ReadString(); + break; + } + case 66: { + if (timestamp_ == null) { + Timestamp = new global::Google.Protobuf.WellKnownTypes.Timestamp(); + } + input.ReadMessage(Timestamp); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[86]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteRequest(RouteRequest other) : this() { + switch (other.CommandCase) { + case CommandOneofCase.RouteToCall: + RouteToCall = other.RouteToCall.Clone(); + break; + case CommandOneofCase.RouteToGetAttributes: + RouteToGetAttributes = other.RouteToGetAttributes.Clone(); + break; + case CommandOneofCase.RouteToSetAttributes: + RouteToSetAttributes = other.RouteToSetAttributes.Clone(); + break; + case CommandOneofCase.RouteToWaitForAttribute: + RouteToWaitForAttribute = other.RouteToWaitForAttribute.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteRequest Clone() { + return new RouteRequest(this); + } + + /// Field number for the "route_to_call" field. + public const int RouteToCallFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto RouteToCall { + get { return commandCase_ == CommandOneofCase.RouteToCall ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RouteToCall; + } + } + + /// Field number for the "route_to_get_attributes" field. + public const int RouteToGetAttributesFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto RouteToGetAttributes { + get { return commandCase_ == CommandOneofCase.RouteToGetAttributes ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RouteToGetAttributes; + } + } + + /// Field number for the "route_to_set_attributes" field. + public const int RouteToSetAttributesFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto RouteToSetAttributes { + get { return commandCase_ == CommandOneofCase.RouteToSetAttributes ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RouteToSetAttributes; + } + } + + /// Field number for the "route_to_wait_for_attribute" field. + public const int RouteToWaitForAttributeFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto RouteToWaitForAttribute { + get { return commandCase_ == CommandOneofCase.RouteToWaitForAttribute ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto) command_ : null; } + set { + command_ = value; + commandCase_ = value == null ? CommandOneofCase.None : CommandOneofCase.RouteToWaitForAttribute; + } + } + + private object command_; + /// Enum of possible cases for the "command" oneof. + public enum CommandOneofCase { + None = 0, + RouteToCall = 1, + RouteToGetAttributes = 2, + RouteToSetAttributes = 3, + RouteToWaitForAttribute = 4, + } + private CommandOneofCase commandCase_ = CommandOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public CommandOneofCase CommandCase { + get { return commandCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearCommand() { + commandCase_ = CommandOneofCase.None; + command_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RouteToCall, other.RouteToCall)) return false; + if (!object.Equals(RouteToGetAttributes, other.RouteToGetAttributes)) return false; + if (!object.Equals(RouteToSetAttributes, other.RouteToSetAttributes)) return false; + if (!object.Equals(RouteToWaitForAttribute, other.RouteToWaitForAttribute)) return false; + if (CommandCase != other.CommandCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (commandCase_ == CommandOneofCase.RouteToCall) hash ^= RouteToCall.GetHashCode(); + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) hash ^= RouteToGetAttributes.GetHashCode(); + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) hash ^= RouteToSetAttributes.GetHashCode(); + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) hash ^= RouteToWaitForAttribute.GetHashCode(); + hash ^= (int) commandCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (commandCase_ == CommandOneofCase.RouteToCall) { + output.WriteRawTag(10); + output.WriteMessage(RouteToCall); + } + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) { + output.WriteRawTag(18); + output.WriteMessage(RouteToGetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) { + output.WriteRawTag(26); + output.WriteMessage(RouteToSetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) { + output.WriteRawTag(34); + output.WriteMessage(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (commandCase_ == CommandOneofCase.RouteToCall) { + output.WriteRawTag(10); + output.WriteMessage(RouteToCall); + } + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) { + output.WriteRawTag(18); + output.WriteMessage(RouteToGetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) { + output.WriteRawTag(26); + output.WriteMessage(RouteToSetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) { + output.WriteRawTag(34); + output.WriteMessage(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (commandCase_ == CommandOneofCase.RouteToCall) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToCall); + } + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToGetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToSetAttributes); + } + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteRequest other) { + if (other == null) { + return; + } + switch (other.CommandCase) { + case CommandOneofCase.RouteToCall: + if (RouteToCall == null) { + RouteToCall = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto(); + } + RouteToCall.MergeFrom(other.RouteToCall); + break; + case CommandOneofCase.RouteToGetAttributes: + if (RouteToGetAttributes == null) { + RouteToGetAttributes = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto(); + } + RouteToGetAttributes.MergeFrom(other.RouteToGetAttributes); + break; + case CommandOneofCase.RouteToSetAttributes: + if (RouteToSetAttributes == null) { + RouteToSetAttributes = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto(); + } + RouteToSetAttributes.MergeFrom(other.RouteToSetAttributes); + break; + case CommandOneofCase.RouteToWaitForAttribute: + if (RouteToWaitForAttribute == null) { + RouteToWaitForAttribute = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto(); + } + RouteToWaitForAttribute.MergeFrom(other.RouteToWaitForAttribute); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToCall) { + subBuilder.MergeFrom(RouteToCall); + } + input.ReadMessage(subBuilder); + RouteToCall = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) { + subBuilder.MergeFrom(RouteToGetAttributes); + } + input.ReadMessage(subBuilder); + RouteToGetAttributes = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) { + subBuilder.MergeFrom(RouteToSetAttributes); + } + input.ReadMessage(subBuilder); + RouteToSetAttributes = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) { + subBuilder.MergeFrom(RouteToWaitForAttribute); + } + input.ReadMessage(subBuilder); + RouteToWaitForAttribute = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToCall) { + subBuilder.MergeFrom(RouteToCall); + } + input.ReadMessage(subBuilder); + RouteToCall = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToGetAttributes) { + subBuilder.MergeFrom(RouteToGetAttributes); + } + input.ReadMessage(subBuilder); + RouteToGetAttributes = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToSetAttributes) { + subBuilder.MergeFrom(RouteToSetAttributes); + } + input.ReadMessage(subBuilder); + RouteToSetAttributes = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeRequestDto(); + if (commandCase_ == CommandOneofCase.RouteToWaitForAttribute) { + subBuilder.MergeFrom(RouteToWaitForAttribute); + } + input.ReadMessage(subBuilder); + RouteToWaitForAttribute = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class RouteReply : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RouteReply()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[87]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteReply() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteReply(RouteReply other) : this() { + switch (other.ReplyCase) { + case ReplyOneofCase.RouteToCall: + RouteToCall = other.RouteToCall.Clone(); + break; + case ReplyOneofCase.RouteToGetAttributes: + RouteToGetAttributes = other.RouteToGetAttributes.Clone(); + break; + case ReplyOneofCase.RouteToSetAttributes: + RouteToSetAttributes = other.RouteToSetAttributes.Clone(); + break; + case ReplyOneofCase.RouteToWaitForAttribute: + RouteToWaitForAttribute = other.RouteToWaitForAttribute.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public RouteReply Clone() { + return new RouteReply(this); + } + + /// Field number for the "route_to_call" field. + public const int RouteToCallFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto RouteToCall { + get { return replyCase_ == ReplyOneofCase.RouteToCall ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.RouteToCall; + } + } + + /// Field number for the "route_to_get_attributes" field. + public const int RouteToGetAttributesFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto RouteToGetAttributes { + get { return replyCase_ == ReplyOneofCase.RouteToGetAttributes ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.RouteToGetAttributes; + } + } + + /// Field number for the "route_to_set_attributes" field. + public const int RouteToSetAttributesFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto RouteToSetAttributes { + get { return replyCase_ == ReplyOneofCase.RouteToSetAttributes ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.RouteToSetAttributes; + } + } + + /// Field number for the "route_to_wait_for_attribute" field. + public const int RouteToWaitForAttributeFieldNumber = 4; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto RouteToWaitForAttribute { + get { return replyCase_ == ReplyOneofCase.RouteToWaitForAttribute ? (global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto) reply_ : null; } + set { + reply_ = value; + replyCase_ = value == null ? ReplyOneofCase.None : ReplyOneofCase.RouteToWaitForAttribute; + } + } + + private object reply_; + /// Enum of possible cases for the "reply" oneof. + public enum ReplyOneofCase { + None = 0, + RouteToCall = 1, + RouteToGetAttributes = 2, + RouteToSetAttributes = 3, + RouteToWaitForAttribute = 4, + } + private ReplyOneofCase replyCase_ = ReplyOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ReplyOneofCase ReplyCase { + get { return replyCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReply() { + replyCase_ = ReplyOneofCase.None; + reply_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as RouteReply); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(RouteReply other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RouteToCall, other.RouteToCall)) return false; + if (!object.Equals(RouteToGetAttributes, other.RouteToGetAttributes)) return false; + if (!object.Equals(RouteToSetAttributes, other.RouteToSetAttributes)) return false; + if (!object.Equals(RouteToWaitForAttribute, other.RouteToWaitForAttribute)) return false; + if (ReplyCase != other.ReplyCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (replyCase_ == ReplyOneofCase.RouteToCall) hash ^= RouteToCall.GetHashCode(); + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) hash ^= RouteToGetAttributes.GetHashCode(); + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) hash ^= RouteToSetAttributes.GetHashCode(); + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) hash ^= RouteToWaitForAttribute.GetHashCode(); + hash ^= (int) replyCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (replyCase_ == ReplyOneofCase.RouteToCall) { + output.WriteRawTag(10); + output.WriteMessage(RouteToCall); + } + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) { + output.WriteRawTag(18); + output.WriteMessage(RouteToGetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) { + output.WriteRawTag(26); + output.WriteMessage(RouteToSetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) { + output.WriteRawTag(34); + output.WriteMessage(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (replyCase_ == ReplyOneofCase.RouteToCall) { + output.WriteRawTag(10); + output.WriteMessage(RouteToCall); + } + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) { + output.WriteRawTag(18); + output.WriteMessage(RouteToGetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) { + output.WriteRawTag(26); + output.WriteMessage(RouteToSetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) { + output.WriteRawTag(34); + output.WriteMessage(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (replyCase_ == ReplyOneofCase.RouteToCall) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToCall); + } + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToGetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToSetAttributes); + } + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RouteToWaitForAttribute); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(RouteReply other) { + if (other == null) { + return; + } + switch (other.ReplyCase) { + case ReplyOneofCase.RouteToCall: + if (RouteToCall == null) { + RouteToCall = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto(); + } + RouteToCall.MergeFrom(other.RouteToCall); + break; + case ReplyOneofCase.RouteToGetAttributes: + if (RouteToGetAttributes == null) { + RouteToGetAttributes = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto(); + } + RouteToGetAttributes.MergeFrom(other.RouteToGetAttributes); + break; + case ReplyOneofCase.RouteToSetAttributes: + if (RouteToSetAttributes == null) { + RouteToSetAttributes = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto(); + } + RouteToSetAttributes.MergeFrom(other.RouteToSetAttributes); + break; + case ReplyOneofCase.RouteToWaitForAttribute: + if (RouteToWaitForAttribute == null) { + RouteToWaitForAttribute = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto(); + } + RouteToWaitForAttribute.MergeFrom(other.RouteToWaitForAttribute); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToCall) { + subBuilder.MergeFrom(RouteToCall); + } + input.ReadMessage(subBuilder); + RouteToCall = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) { + subBuilder.MergeFrom(RouteToGetAttributes); + } + input.ReadMessage(subBuilder); + RouteToGetAttributes = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) { + subBuilder.MergeFrom(RouteToSetAttributes); + } + input.ReadMessage(subBuilder); + RouteToSetAttributes = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) { + subBuilder.MergeFrom(RouteToWaitForAttribute); + } + input.ReadMessage(subBuilder); + RouteToWaitForAttribute = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToCallResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToCall) { + subBuilder.MergeFrom(RouteToCall); + } + input.ReadMessage(subBuilder); + RouteToCall = subBuilder; + break; + } + case 18: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToGetAttributesResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToGetAttributes) { + subBuilder.MergeFrom(RouteToGetAttributes); + } + input.ReadMessage(subBuilder); + RouteToGetAttributes = subBuilder; + break; + } + case 26: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToSetAttributesResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToSetAttributes) { + subBuilder.MergeFrom(RouteToSetAttributes); + } + input.ReadMessage(subBuilder); + RouteToSetAttributes = subBuilder; + break; + } + case 34: { + global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto subBuilder = new global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteToWaitForAttributeResponseDto(); + if (replyCase_ == ReplyOneofCase.RouteToWaitForAttribute) { + subBuilder.MergeFrom(RouteToWaitForAttribute); + } + input.ReadMessage(subBuilder); + RouteToWaitForAttribute = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TriggerSiteFailoverDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TriggerSiteFailoverDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[88]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TriggerSiteFailoverDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TriggerSiteFailoverDto(TriggerSiteFailoverDto other) : this() { + correlationId_ = other.correlationId_; + siteId_ = other.siteId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TriggerSiteFailoverDto Clone() { + return new TriggerSiteFailoverDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "site_id" field. + public const int SiteIdFieldNumber = 2; + private string siteId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SiteId { + get { return siteId_; } + set { + siteId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TriggerSiteFailoverDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TriggerSiteFailoverDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (SiteId != other.SiteId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (SiteId.Length != 0) hash ^= SiteId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (SiteId.Length != 0) { + output.WriteRawTag(18); + output.WriteString(SiteId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (SiteId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SiteId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TriggerSiteFailoverDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.SiteId.Length != 0) { + SiteId = other.SiteId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 18: { + SiteId = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SiteFailoverAckDto : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SiteFailoverAckDto()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.MessageTypes[89]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SiteFailoverAckDto() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SiteFailoverAckDto(SiteFailoverAckDto other) : this() { + correlationId_ = other.correlationId_; + accepted_ = other.accepted_; + targetAddress_ = other.targetAddress_; + errorMessage_ = other.errorMessage_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SiteFailoverAckDto Clone() { + return new SiteFailoverAckDto(this); + } + + /// Field number for the "correlation_id" field. + public const int CorrelationIdFieldNumber = 1; + private string correlationId_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string CorrelationId { + get { return correlationId_; } + set { + correlationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "accepted" field. + public const int AcceptedFieldNumber = 2; + private bool accepted_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Accepted { + get { return accepted_; } + set { + accepted_ = value; + } + } + + /// Field number for the "target_address" field. + public const int TargetAddressFieldNumber = 3; + private string targetAddress_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string TargetAddress { + get { return targetAddress_; } + set { + targetAddress_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "error_message" field. + public const int ErrorMessageFieldNumber = 4; + private string errorMessage_ = ""; + /// + /// empty string represents null + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ErrorMessage { + get { return errorMessage_; } + set { + errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SiteFailoverAckDto); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SiteFailoverAckDto other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (CorrelationId != other.CorrelationId) return false; + if (Accepted != other.Accepted) return false; + if (TargetAddress != other.TargetAddress) return false; + if (ErrorMessage != other.ErrorMessage) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (CorrelationId.Length != 0) hash ^= CorrelationId.GetHashCode(); + if (Accepted != false) hash ^= Accepted.GetHashCode(); + if (TargetAddress.Length != 0) hash ^= TargetAddress.GetHashCode(); + if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Accepted != false) { + output.WriteRawTag(16); + output.WriteBool(Accepted); + } + if (TargetAddress.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TargetAddress); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (CorrelationId.Length != 0) { + output.WriteRawTag(10); + output.WriteString(CorrelationId); + } + if (Accepted != false) { + output.WriteRawTag(16); + output.WriteBool(Accepted); + } + if (TargetAddress.Length != 0) { + output.WriteRawTag(26); + output.WriteString(TargetAddress); + } + if (ErrorMessage.Length != 0) { + output.WriteRawTag(34); + output.WriteString(ErrorMessage); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (CorrelationId.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(CorrelationId); + } + if (Accepted != false) { + size += 1 + 1; + } + if (TargetAddress.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(TargetAddress); + } + if (ErrorMessage.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SiteFailoverAckDto other) { + if (other == null) { + return; + } + if (other.CorrelationId.Length != 0) { + CorrelationId = other.CorrelationId; + } + if (other.Accepted != false) { + Accepted = other.Accepted; + } + if (other.TargetAddress.Length != 0) { + TargetAddress = other.TargetAddress; + } + if (other.ErrorMessage.Length != 0) { + ErrorMessage = other.ErrorMessage; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Accepted = input.ReadBool(); + break; + } + case 26: { + TargetAddress = input.ReadString(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + CorrelationId = input.ReadString(); + break; + } + case 16: { + Accepted = input.ReadBool(); + break; + } + case 26: { + TargetAddress = input.ReadString(); + break; + } + case 34: { + ErrorMessage = input.ReadString(); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommandGrpc.cs b/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommandGrpc.cs new file mode 100644 index 00000000..1235162a --- /dev/null +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommandGrpc.cs @@ -0,0 +1,559 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Protos/site_command.proto +// +#pragma warning disable 0414, 1591, 8981, 0612 +#region Designer generated code + +using grpc = global::Grpc.Core; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc { + public static partial class SiteCommandService + { + static readonly string __ServiceName = "scadabridge.sitecommand.v1.SiteCommandService"; + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context) + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (message is global::Google.Protobuf.IBufferMessage) + { + context.SetPayloadLength(message.CalculateSize()); + global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter()); + context.Complete(); + return; + } + #endif + context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static class __Helper_MessageCache + { + public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T)); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static T __Helper_DeserializeMessage(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser parser) where T : global::Google.Protobuf.IMessage + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (__Helper_MessageCache.IsBufferMessage) + { + return parser.ParseFrom(context.PayloadAsReadOnlySequence()); + } + #endif + return parser.ParseFrom(context.PayloadAsNewBuffer()); + } + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_LifecycleRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_LifecycleReply = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleReply.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_OpcUaRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_OpcUaReply = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaReply.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_QueryRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_QueryReply = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryReply.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_ParkedRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_ParkedReply = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedReply.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_RouteRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_RouteReply = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteReply.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_TriggerSiteFailoverDto = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto.Parser)); + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Marshaller __Marshaller_scadabridge_sitecommand_v1_SiteFailoverAckDto = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteFailoverAckDto.Parser)); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteLifecycle = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteLifecycle", + __Marshaller_scadabridge_sitecommand_v1_LifecycleRequest, + __Marshaller_scadabridge_sitecommand_v1_LifecycleReply); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteOpcUa = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteOpcUa", + __Marshaller_scadabridge_sitecommand_v1_OpcUaRequest, + __Marshaller_scadabridge_sitecommand_v1_OpcUaReply); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteQuery = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteQuery", + __Marshaller_scadabridge_sitecommand_v1_QueryRequest, + __Marshaller_scadabridge_sitecommand_v1_QueryReply); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteParked = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteParked", + __Marshaller_scadabridge_sitecommand_v1_ParkedRequest, + __Marshaller_scadabridge_sitecommand_v1_ParkedReply); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_ExecuteRoute = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "ExecuteRoute", + __Marshaller_scadabridge_sitecommand_v1_RouteRequest, + __Marshaller_scadabridge_sitecommand_v1_RouteReply); + + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + static readonly grpc::Method __Method_TriggerFailover = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "TriggerFailover", + __Marshaller_scadabridge_sitecommand_v1_TriggerSiteFailoverDto, + __Marshaller_scadabridge_sitecommand_v1_SiteFailoverAckDto); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandReflection.Descriptor.Services[0]; } + } + + /// Base class for server-side implementations of SiteCommandService + [grpc::BindServiceMethod(typeof(SiteCommandService), "BindService")] + public abstract partial class SiteCommandServiceBase + { + /// + /// Deployment + instance lifecycle (6 commands). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteLifecycle(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Interactive OPC UA / MxGateway design-time commands (8 commands). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteOpcUa(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Remote read-only queries: event log + debug view (4 commands). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteQuery(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Parked store-and-forward message + cached-operation actions (5 commands). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteParked(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Inbound-API Route.To() relays (4 commands). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task ExecuteRoute(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + /// + /// Operator-initiated manual site-pair failover (1 command). + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::System.Threading.Tasks.Task TriggerFailover(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for SiteCommandService + public partial class SiteCommandServiceClient : grpc::ClientBase + { + /// Creates a new client for SiteCommandService + /// The channel to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public SiteCommandServiceClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for SiteCommandService that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public SiteCommandServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected SiteCommandServiceClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected SiteCommandServiceClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + /// + /// Deployment + instance lifecycle (6 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleReply ExecuteLifecycle(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteLifecycle(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Deployment + instance lifecycle (6 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleReply ExecuteLifecycle(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteLifecycle, null, options, request); + } + /// + /// Deployment + instance lifecycle (6 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteLifecycleAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteLifecycleAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Deployment + instance lifecycle (6 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteLifecycleAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.LifecycleRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteLifecycle, null, options, request); + } + /// + /// Interactive OPC UA / MxGateway design-time commands (8 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaReply ExecuteOpcUa(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteOpcUa(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Interactive OPC UA / MxGateway design-time commands (8 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaReply ExecuteOpcUa(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteOpcUa, null, options, request); + } + /// + /// Interactive OPC UA / MxGateway design-time commands (8 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteOpcUaAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteOpcUaAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Interactive OPC UA / MxGateway design-time commands (8 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteOpcUaAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.OpcUaRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteOpcUa, null, options, request); + } + /// + /// Remote read-only queries: event log + debug view (4 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryReply ExecuteQuery(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteQuery(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Remote read-only queries: event log + debug view (4 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryReply ExecuteQuery(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteQuery, null, options, request); + } + /// + /// Remote read-only queries: event log + debug view (4 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteQueryAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteQueryAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Remote read-only queries: event log + debug view (4 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteQueryAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.QueryRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteQuery, null, options, request); + } + /// + /// Parked store-and-forward message + cached-operation actions (5 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedReply ExecuteParked(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteParked(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Parked store-and-forward message + cached-operation actions (5 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedReply ExecuteParked(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteParked, null, options, request); + } + /// + /// Parked store-and-forward message + cached-operation actions (5 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteParkedAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteParkedAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Parked store-and-forward message + cached-operation actions (5 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteParkedAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.ParkedRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteParked, null, options, request); + } + /// + /// Inbound-API Route.To() relays (4 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteReply ExecuteRoute(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteRoute(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Inbound-API Route.To() relays (4 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteReply ExecuteRoute(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_ExecuteRoute, null, options, request); + } + /// + /// Inbound-API Route.To() relays (4 commands). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteRouteAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ExecuteRouteAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Inbound-API Route.To() relays (4 commands). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall ExecuteRouteAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.RouteRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_ExecuteRoute, null, options, request); + } + /// + /// Operator-initiated manual site-pair failover (1 command). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteFailoverAckDto TriggerFailover(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return TriggerFailover(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Operator-initiated manual site-pair failover (1 command). + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteFailoverAckDto TriggerFailover(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_TriggerFailover, null, options, request); + } + /// + /// Operator-initiated manual site-pair failover (1 command). + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall TriggerFailoverAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return TriggerFailoverAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Operator-initiated manual site-pair failover (1 command). + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public virtual grpc::AsyncUnaryCall TriggerFailoverAsync(global::ZB.MOM.WW.ScadaBridge.Communication.Grpc.TriggerSiteFailoverDto request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_TriggerFailover, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + protected override SiteCommandServiceClient NewInstance(ClientBaseConfiguration configuration) + { + return new SiteCommandServiceClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static grpc::ServerServiceDefinition BindService(SiteCommandServiceBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_ExecuteLifecycle, serviceImpl.ExecuteLifecycle) + .AddMethod(__Method_ExecuteOpcUa, serviceImpl.ExecuteOpcUa) + .AddMethod(__Method_ExecuteQuery, serviceImpl.ExecuteQuery) + .AddMethod(__Method_ExecuteParked, serviceImpl.ExecuteParked) + .AddMethod(__Method_ExecuteRoute, serviceImpl.ExecuteRoute) + .AddMethod(__Method_TriggerFailover, serviceImpl.TriggerFailover).Build(); + } + + /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. + /// Note: this method is part of an experimental API that can change or be removed without any prior notice. + /// Service methods will be bound by calling AddMethod on this object. + /// An object implementing the server-side handling logic. + [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)] + public static void BindService(grpc::ServiceBinderBase serviceBinder, SiteCommandServiceBase serviceImpl) + { + serviceBinder.AddMethod(__Method_ExecuteLifecycle, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteLifecycle)); + serviceBinder.AddMethod(__Method_ExecuteOpcUa, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteOpcUa)); + serviceBinder.AddMethod(__Method_ExecuteQuery, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteQuery)); + serviceBinder.AddMethod(__Method_ExecuteParked, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteParked)); + serviceBinder.AddMethod(__Method_ExecuteRoute, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.ExecuteRoute)); + serviceBinder.AddMethod(__Method_TriggerFailover, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.TriggerFailover)); + } + + } +} +#endregion diff --git a/src/ZB.MOM.WW.ScadaBridge.Communication/ZB.MOM.WW.ScadaBridge.Communication.csproj b/src/ZB.MOM.WW.ScadaBridge.Communication/ZB.MOM.WW.ScadaBridge.Communication.csproj index 116be08e..03c45753 100644 --- a/src/ZB.MOM.WW.ScadaBridge.Communication/ZB.MOM.WW.ScadaBridge.Communication.csproj +++ b/src/ZB.MOM.WW.ScadaBridge.Communication/ZB.MOM.WW.ScadaBridge.Communication.csproj @@ -32,30 +32,31 @@ - + central_control.proto imports sitestream.proto, so protoc resolves it from the + project-relative path without sitestream.proto needing its own Protobuf item. + An ACTIVE Protobuf item must never be committed — it breaks the Docker image + build. Eventually we should switch the Docker build image to one with a working + protoc on arm64. --> diff --git a/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/LooseValueCodecTests.cs b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/LooseValueCodecTests.cs new file mode 100644 index 00000000..c6d02191 --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/LooseValueCodecTests.cs @@ -0,0 +1,153 @@ +using System.Text.Json; +using ZB.MOM.WW.ScadaBridge.Communication.Grpc; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Tests; + +/// +/// Goldens for — the type-tagged carrier for the +/// object? members of the site command plane (script parameters and +/// return values, attribute values, tag reads/writes). +/// +/// +/// The contract these tests pin down is that a boxed value keeps its RUNTIME +/// CLR TYPE across the wire, not merely its printed form. Today's Akka JSON +/// serializer preserves it, and an operator-facing tag value that silently +/// turns from int into long (or from DateTime into a +/// UTC-normalised copy) is a behaviour change, not a refactor. +/// +public class LooseValueCodecTests +{ + public static IEnumerable TaggedScalars() => + [ + [true], + [false], + [42], + [-1], + [long.MaxValue], + [3.5d], + [1.5f], + ["a string"], + [string.Empty], + [12.3456789m], + [new DateTime(2026, 7, 22, 1, 2, 3, DateTimeKind.Utc)], + [new DateTimeOffset(2026, 7, 22, 1, 2, 3, TimeSpan.FromHours(-5))], + [Guid.Parse("11111111-2222-3333-4444-555555555555")], + [TimeSpan.FromMinutes(90)], + [new byte[] { 1, 2, 3 }] + ]; + + [Theory] + [MemberData(nameof(TaggedScalars))] + public void TaggedValues_KeepTheirClrType(object value) + { + var restored = LooseValueCodec.FromProto(LooseValueCodec.ToProto(value)); + + Assert.NotNull(restored); + Assert.Equal(value.GetType(), restored.GetType()); + StructuralEquality.AssertDeepEqual(value, restored, value.GetType().Name); + } + + /// + /// A local must come back local, and an offset + /// must come back with the same offset — the + /// reason these ride as round-trip strings instead of proto timestamps. + /// + [Fact] + public void DateValues_KeepKindAndOffset() + { + var local = new DateTime(2026, 7, 22, 1, 2, 3, DateTimeKind.Local); + var offset = new DateTimeOffset(2026, 7, 22, 1, 2, 3, TimeSpan.FromHours(5.5)); + + var restoredLocal = Assert.IsType(LooseValueCodec.FromProto(LooseValueCodec.ToProto(local))); + var restoredOffset = + Assert.IsType(LooseValueCodec.FromProto(LooseValueCodec.ToProto(offset))); + + Assert.Equal(DateTimeKind.Local, restoredLocal.Kind); + Assert.Equal(local, restoredLocal); + Assert.Equal(TimeSpan.FromHours(5.5), restoredOffset.Offset); + } + + /// An unset carrier and an explicit null marker both decode to null. + [Fact] + public void NullIsCarriedTwoWays() + { + Assert.Null(LooseValueCodec.FromProto(null)); + Assert.Null(LooseValueCodec.FromProto(LooseValueCodec.ToProto(null))); + Assert.Null(LooseValueCodec.ToProtoOrNull(null)); + } + + /// + /// A dictionary entry whose value is null stays distinct from an absent key — + /// the reason LooseNull exists at all. + /// + [Fact] + public void NullMapValue_SurvivesAsAPresentKey() + { + var original = new Dictionary { ["present"] = null }; + + var restored = LooseValueCodec.FromProtoMap(LooseValueCodec.ToProtoMap(original)); + + Assert.True(restored.ContainsKey("present")); + Assert.Null(restored["present"]); + } + + /// A null dictionary stays null; an empty one stays empty. + [Fact] + public void NullMap_StaysDistinctFromEmptyMap() + { + Assert.Null(LooseValueCodec.ToProtoMapOrNull(null)); + Assert.Null(LooseValueCodec.FromProtoMapOrNull(null)); + + var empty = LooseValueCodec.FromProtoMapOrNull( + LooseValueCodec.ToProtoMapOrNull(new Dictionary())); + + Assert.NotNull(empty); + Assert.Empty(empty); + } + + /// Nested lists and maps recurse, so element values keep their types too. + [Fact] + public void NestedCollections_KeepElementTypes() + { + object original = new List + { + 1, + "two", + null, + new Dictionary { ["deep"] = 3.5d } + }; + + var restored = LooseValueCodec.FromProto(LooseValueCodec.ToProto(original)); + + StructuralEquality.AssertDeepEqual(original, restored, "list"); + } + + /// + /// The documented widening: a typed collection keeps its ELEMENTS' types but + /// the container comes back as List<object?>. Recorded here so + /// the behaviour is a decision rather than a surprise. + /// + [Fact] + public void TypedList_WidensToObjectList() + { + var restored = LooseValueCodec.FromProto(LooseValueCodec.ToProto(new List { 1, 2, 3 })); + + var list = Assert.IsType>(restored); + Assert.Equal([1, 2, 3], list.Cast()); + } + + /// + /// The documented lossy escape hatch: a value outside the tagged set keeps its + /// DATA but not its CLR identity — it decodes as a . + /// Nothing on the command plane carries such a value today; the fallback + /// exists so an unexpected one cannot fault a command. + /// + [Fact] + public void UntaggedValue_FallsBackToJsonAndLosesItsClrType() + { + var restored = LooseValueCodec.FromProto(LooseValueCodec.ToProto((byte)7)); + + var element = Assert.IsType(restored); + Assert.Equal("7", element.GetRawText()); + } +} diff --git a/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandDtoMapperGoldenTests.cs b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandDtoMapperGoldenTests.cs new file mode 100644 index 00000000..16499a40 --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandDtoMapperGoldenTests.cs @@ -0,0 +1,569 @@ +using System.Reflection; +using Google.Protobuf; +using Google.Protobuf.Reflection; +using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Protocol; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.InboundApi; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Streaming; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Alarms; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums; +using ZB.MOM.WW.ScadaBridge.Communication.Grpc; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Tests; + +/// +/// Round-trip goldens for — the 28 migrated +/// central→site commands, all 22 reply shapes, and every nested type they +/// carry, each proven to survive record → proto → record unchanged. +/// +/// +/// +/// The suite is REFLECTION-DRIVEN on purpose. Both the per-type theory and the +/// coverage guards enumerate the mapper's real surface (its ToProto +/// overloads) and the real proto contract (the generated oneof +/// descriptors), so adding a command without a golden fails the build rather +/// than quietly shipping an untested field. A hand-maintained list across 50 +/// types would drift on the first change. +/// +/// +/// Where a round trip is not bit-exact, the mapper is the thing that gets fixed +/// — never the fixture. The two deliberate normalisations +/// (empty-string-means-null, and the implicit alarm Condition) are +/// asserted explicitly below rather than papered over. +/// +/// +public class SiteCommandDtoMapperGoldenTests +{ + private static readonly IReadOnlyDictionary TypesByName = + SiteCommandSamples.All.Keys.ToDictionary(t => t.FullName!, t => t); + + /// One theory case per (mapped type, golden sample). + /// Type name and sample index pairs covering every golden fixture. + public static IEnumerable AllSamples() => + SiteCommandSamples.All + .OrderBy(kv => kv.Key.FullName, StringComparer.Ordinal) + .SelectMany(kv => Enumerable.Range(0, kv.Value.Length) + .Select(i => new object[] { kv.Key.FullName!, i })); + + [Theory] + [MemberData(nameof(AllSamples))] + public void RoundTrips_Unchanged(string typeName, int sampleIndex) + { + var type = TypesByName[typeName]; + var original = SiteCommandSamples.All[type][sampleIndex]; + + var restored = RoundTrip(original, type); + + StructuralEquality.AssertDeepEqual(original, restored, type.Name); + } + + // ───────────────────────────────────────────────────────────────────── + // Coverage guards + // ───────────────────────────────────────────────────────────────────── + + /// + /// Every non-enum type the mapper can project must have goldens. This is the + /// guard that makes the suite self-maintaining. + /// + [Fact] + public void EveryMappedType_HasGoldenSamples() + { + var missing = MappedRecordTypes() + .Where(t => !SiteCommandSamples.All.ContainsKey(t)) + .Select(t => t.Name) + .OrderBy(n => n, StringComparer.Ordinal) + .ToList(); + + Assert.True( + missing.Count == 0, + "SiteCommandDtoMapper projects types with no golden sample: " + string.Join(", ", missing)); + } + + /// Every golden sample type must have at least two samples (populated + minimal). + [Fact] + public void EveryGoldenType_HasAtLeastOneSample() + { + var empty = SiteCommandSamples.All + .Where(kv => kv.Value.Length == 0) + .Select(kv => kv.Key.Name) + .ToList(); + + Assert.True(empty.Count == 0, "Golden types with no samples: " + string.Join(", ", empty)); + } + + /// + /// The contract carries exactly 28 commands — 29 on + /// SiteCommunicationActor's receive table minus the dead + /// IntegrationCallRequest. If the site gains a command, this count + /// moves deliberately, not silently. + /// + [Fact] + public void CommandInventory_Is28_AcrossSixGroups() + { + var commands = CommandSampleTypes().ToList(); + + Assert.Equal(28, commands.Count); + Assert.Equal( + [6, 8, 4, 5, 4, 1], + new[] + { + SiteCommandGroup.Lifecycle, SiteCommandGroup.OpcUa, SiteCommandGroup.Query, + SiteCommandGroup.Parked, SiteCommandGroup.Route, SiteCommandGroup.Failover + }.Select(g => commands.Count(t => SiteCommandDtoMapper.GroupOf(Sample(t)) == g)).ToArray()); + } + + /// The contract carries 22 reply shapes across the same six groups. + [Fact] + public void ReplyInventory_Is22_AcrossSixGroups() + { + var replies = ReplyTypes().ToList(); + + Assert.Equal(22, replies.Count); + Assert.Equal( + [4, 6, 3, 4, 4, 1], + new[] + { + SiteCommandGroup.Lifecycle, SiteCommandGroup.OpcUa, SiteCommandGroup.Query, + SiteCommandGroup.Parked, SiteCommandGroup.Route, SiteCommandGroup.Failover + }.Select(g => replies.Count(t => SiteCommandDtoMapper.GroupOfReply(SampleReply(t)) == g)).ToArray()); + } + + /// + /// Packing every command golden must exercise EVERY oneof case + /// declared in the four multi-command request envelopes. A new proto case + /// with no producing command fails here. + /// + [Theory] + [MemberData(nameof(RequestEnvelopes))] + public void EveryRequestOneofCase_IsProducedByACommand(string envelopeName) + { + var produced = CommandSampleTypes() + .Select(t => PackCommand(Sample(t))) + .OfType() + .Where(m => m.Descriptor.Name == envelopeName) + .Select(OneofCaseName) + .ToHashSet(StringComparer.Ordinal); + + var declared = DescriptorFor(envelopeName).Oneofs[0].Fields + .Select(f => f.PropertyName) + .ToHashSet(StringComparer.Ordinal); + + Assert.Equal(declared.OrderBy(n => n, StringComparer.Ordinal), produced.OrderBy(n => n, StringComparer.Ordinal)); + } + + /// The reply-envelope mirror of . + [Theory] + [MemberData(nameof(ReplyEnvelopes))] + public void EveryReplyOneofCase_IsProducedByAReply(string envelopeName) + { + var produced = ReplyTypes() + .Select(t => PackReply(SampleReply(t))) + .OfType() + .Where(m => m.Descriptor.Name == envelopeName) + .Select(OneofCaseName) + .ToHashSet(StringComparer.Ordinal); + + var declared = DescriptorFor(envelopeName).Oneofs[0].Fields + .Select(f => f.PropertyName) + .ToHashSet(StringComparer.Ordinal); + + Assert.Equal(declared.OrderBy(n => n, StringComparer.Ordinal), produced.OrderBy(n => n, StringComparer.Ordinal)); + } + + /// Names of the four multi-command request envelopes. + /// Envelope message names. + public static IEnumerable RequestEnvelopes() => + [["LifecycleRequest"], ["OpcUaRequest"], ["QueryRequest"], ["ParkedRequest"], ["RouteRequest"]]; + + /// Names of the four multi-reply reply envelopes. + /// Envelope message names. + public static IEnumerable ReplyEnvelopes() => + [["LifecycleReply"], ["OpcUaReply"], ["QueryReply"], ["ParkedReply"], ["RouteReply"]]; + + /// Every command golden survives the full envelope pack/unpack, not just its own message. + [Fact] + public void EveryCommandGolden_SurvivesItsEnvelope() + { + foreach (var (type, samples) in SiteCommandSamples.All) + { + if (!IsCommand(type)) + { + continue; + } + + foreach (var sample in samples) + { + var restored = UnpackCommand(PackCommand(sample)); + StructuralEquality.AssertDeepEqual(sample, restored, $"{type.Name}(envelope)"); + } + } + } + + /// Every reply golden survives the full envelope pack/unpack. + [Fact] + public void EveryReplyGolden_SurvivesItsEnvelope() + { + foreach (var (type, samples) in SiteCommandSamples.All) + { + if (!IsReply(type)) + { + continue; + } + + foreach (var sample in samples) + { + var restored = UnpackReply(PackReply(sample)); + StructuralEquality.AssertDeepEqual(sample, restored, $"{type.Name}(envelope)"); + } + } + } + + /// The fire-and-forget unsubscribe ack is a real envelope case, not a special path. + [Fact] + public void UnsubscribeDebugViewAck_RoundTripsThroughQueryReply() + { + var envelope = SiteCommandDtoMapper.ToQueryReply(UnsubscribeDebugViewAck.Instance); + + Assert.Equal(QueryReply.ReplyOneofCase.UnsubscribeDebugView, envelope.ReplyCase); + Assert.Same(UnsubscribeDebugViewAck.Instance, SiteCommandDtoMapper.FromQueryReply(envelope)); + } + + // ───────────────────────────────────────────────────────────────────── + // Enum exhaustiveness + // ───────────────────────────────────────────────────────────────────── + + [Theory] + [InlineData(DeploymentStatus.Pending)] + [InlineData(DeploymentStatus.InProgress)] + [InlineData(DeploymentStatus.Success)] + [InlineData(DeploymentStatus.Failed)] + public void DeploymentStatus_RoundTrips(DeploymentStatus value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(BrowseNodeClass.Object)] + [InlineData(BrowseNodeClass.Variable)] + [InlineData(BrowseNodeClass.Method)] + [InlineData(BrowseNodeClass.Other)] + public void BrowseNodeClass_RoundTrips(BrowseNodeClass value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(BrowseFailureKind.ConnectionNotFound)] + [InlineData(BrowseFailureKind.ConnectionNotConnected)] + [InlineData(BrowseFailureKind.NotBrowsable)] + [InlineData(BrowseFailureKind.Timeout)] + [InlineData(BrowseFailureKind.ServerError)] + public void BrowseFailureKind_RoundTrips(BrowseFailureKind value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(ReadTagValuesFailureKind.ConnectionNotFound)] + [InlineData(ReadTagValuesFailureKind.ConnectionNotConnected)] + [InlineData(ReadTagValuesFailureKind.Timeout)] + [InlineData(ReadTagValuesFailureKind.ServerError)] + public void ReadTagValuesFailureKind_RoundTrips(ReadTagValuesFailureKind value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(VerifyFailureKind.Unreachable)] + [InlineData(VerifyFailureKind.AuthFailed)] + [InlineData(VerifyFailureKind.UntrustedCertificate)] + [InlineData(VerifyFailureKind.Timeout)] + [InlineData(VerifyFailureKind.ServerError)] + public void VerifyFailureKind_RoundTrips(VerifyFailureKind value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(StoreAndForwardCategory.ExternalSystem)] + [InlineData(StoreAndForwardCategory.Notification)] + [InlineData(StoreAndForwardCategory.CachedDbWrite)] + public void StoreAndForwardCategory_RoundTrips(StoreAndForwardCategory value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(AlarmState.Active)] + [InlineData(AlarmState.Normal)] + public void AlarmState_RoundTrips(AlarmState value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(AlarmLevel.None)] + [InlineData(AlarmLevel.Low)] + [InlineData(AlarmLevel.LowLow)] + [InlineData(AlarmLevel.High)] + [InlineData(AlarmLevel.HighHigh)] + public void AlarmLevel_RoundTrips(AlarmLevel value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(AlarmKind.Computed)] + [InlineData(AlarmKind.NativeOpcUa)] + [InlineData(AlarmKind.NativeMxAccess)] + public void AlarmKind_RoundTrips(AlarmKind value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + [Theory] + [InlineData(AlarmShelveState.Unshelved)] + [InlineData(AlarmShelveState.OneShotShelved)] + [InlineData(AlarmShelveState.TimedShelved)] + [InlineData(AlarmShelveState.PermanentShelved)] + public void AlarmShelveState_RoundTrips(AlarmShelveState value) => + Assert.Equal(value, SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(value))); + + /// + /// An unspecified wire enum — what a peer on an older contract sends — must + /// decode to the documented safe default instead of faulting the command. + /// + [Fact] + public void UnspecifiedWireEnums_DecodeToSafeDefaults() + { + Assert.Equal(DeploymentStatus.Failed, SiteCommandDtoMapper.FromProto(DeploymentStatusDto.Unspecified)); + Assert.Equal(BrowseNodeClass.Other, SiteCommandDtoMapper.FromProto(BrowseNodeClassDto.Unspecified)); + Assert.Equal(BrowseFailureKind.ServerError, SiteCommandDtoMapper.FromProto(BrowseFailureKindDto.Unspecified)); + Assert.Equal( + ReadTagValuesFailureKind.ServerError, + SiteCommandDtoMapper.FromProto(ReadTagValuesFailureKindDto.Unspecified)); + Assert.Equal(VerifyFailureKind.ServerError, SiteCommandDtoMapper.FromProto(VerifyFailureKindDto.Unspecified)); + Assert.Equal( + StoreAndForwardCategory.ExternalSystem, + SiteCommandDtoMapper.FromProto(StoreAndForwardCategoryDto.Unspecified)); + Assert.Equal(AlarmState.Normal, SiteCommandDtoMapper.FromProto(AlarmStateDto.Unspecified)); + Assert.Equal(AlarmLevel.None, SiteCommandDtoMapper.FromProto(AlarmLevelDto.Unspecified)); + Assert.Equal(AlarmKind.Computed, SiteCommandDtoMapper.FromProto(AlarmKindDto.Unspecified)); + Assert.Equal(AlarmShelveState.Unshelved, SiteCommandDtoMapper.FromProto(AlarmShelveStateDto.Unspecified)); + } + + // ───────────────────────────────────────────────────────────────────── + // The two deliberate normalisations, asserted rather than hidden + // ───────────────────────────────────────────────────────────────────── + + /// + /// Nullable strings ride as plain proto3 strings, so an empty one comes back + /// as null. Documented in the mapper; asserted here so it stays a choice. + /// + [Fact] + public void EmptyNullableString_NormalisesToNull() + { + var original = new SiteFailoverAck("corr", Accepted: false, TargetAddress: "", ErrorMessage: ""); + + var restored = SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(original)); + + Assert.Null(restored.TargetAddress); + Assert.Null(restored.ErrorMessage); + } + + /// + /// …but NOT for a wait target, where the empty string is a real value. This + /// is why that one field carries a StringValue wrapper. + /// + [Fact] + public void EmptyWaitTarget_StaysDistinctFromNull() + { + var empty = SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto( + new RouteToWaitForAttributeRequest("c", "i", "a", "", TimeSpan.FromSeconds(1), DateTimeOffset.UtcNow))); + var missing = SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto( + new RouteToWaitForAttributeRequest("c", "i", "a", null, TimeSpan.FromSeconds(1), DateTimeOffset.UtcNow))); + + Assert.Equal(string.Empty, empty.TargetValueEncoded); + Assert.Null(missing.TargetValueEncoded); + } + + /// + /// A computed alarm leaves implicit + /// (the record derives it from State + Priority). The encoder omits a + /// condition that already equals that derived value, so the record comes back + /// byte-for-byte equal — including under record equality, which compares the + /// nullable backing field, not the property. + /// + [Fact] + public void ComputedAlarm_KeepsItsImplicitCondition() + { + var original = new AlarmStateChanged("inst", "alarm", AlarmState.Active, 500, DateTimeOffset.UtcNow); + + var dto = SiteCommandDtoMapper.ToProto(original); + var restored = SiteCommandDtoMapper.FromProto(dto); + + Assert.Null(dto.Condition); + Assert.Equal(original, restored); + } + + /// + /// The flip side of the normalisation: a condition set EXPLICITLY to the value + /// the record would have derived comes back implicit. The + /// value is identical — only the + /// record's private "was it set?" bit differs, which no consumer can observe. + /// + [Fact] + public void ExplicitConditionEqualToTheDerivedDefault_NormalisesToImplicit() + { + var original = new AlarmStateChanged("inst", "alarm", AlarmState.Normal, 100, DateTimeOffset.UtcNow) + { + Condition = AlarmConditionStateFactory.ForComputed(AlarmState.Normal, 100) + }; + + var restored = SiteCommandDtoMapper.FromProto(SiteCommandDtoMapper.ToProto(original)); + + Assert.Equal(original.Condition, restored.Condition); + } + + /// A native alarm's explicit, non-derived condition is carried verbatim. + [Fact] + public void NativeAlarm_KeepsItsExplicitCondition() + { + var condition = new AlarmConditionState(true, false, true, AlarmShelveState.PermanentShelved, true, 999); + var original = new AlarmStateChanged("inst", "alarm", AlarmState.Active, 500, DateTimeOffset.UtcNow) + { + Kind = AlarmKind.NativeMxAccess, + Condition = condition + }; + + var dto = SiteCommandDtoMapper.ToProto(original); + var restored = SiteCommandDtoMapper.FromProto(dto); + + Assert.NotNull(dto.Condition); + Assert.Equal(condition, restored.Condition); + } + + // ───────────────────────────────────────────────────────────────────── + // Group classification + rejection + // ───────────────────────────────────────────────────────────────────── + + /// IntegrationCallRequest is excluded by design and must be rejected, not silently dropped. + [Fact] + public void IntegrationCallRequest_IsRejected() + { + var dead = new Commons.Messages.Integration.IntegrationCallRequest( + "corr", "site-a", "Instance", "System", "Method", + new Dictionary(), DateTimeOffset.UtcNow); + + Assert.Throws(() => SiteCommandDtoMapper.GroupOf(dead)); + } + + /// Packing a command into the wrong group's envelope is a hard error, not a silent no-op. + [Fact] + public void PackingIntoTheWrongGroup_Throws() => + Assert.Throws(() => + SiteCommandDtoMapper.ToLifecycleRequest(new DebugSnapshotRequest("inst", "corr"))); + + /// An envelope with no oneof set (a newer peer's unknown case) surfaces as a clear failure. + [Fact] + public void UnsetOneof_ThrowsNotSupported() => + Assert.Throws(() => SiteCommandDtoMapper.FromLifecycleRequest(new LifecycleRequest())); + + // ───────────────────────────────────────────────────────────────────── + // Reflection plumbing + // ───────────────────────────────────────────────────────────────────── + + private static object RoundTrip(object original, Type type) + { + var toProto = typeof(SiteCommandDtoMapper) + .GetMethods(BindingFlags.Public | BindingFlags.Static) + .Single(m => m.Name == "ToProto" && m.GetParameters() is [{ } p] && p.ParameterType == type); + + var wire = toProto.Invoke(null, [original])!; + + var fromProto = typeof(SiteCommandDtoMapper) + .GetMethods(BindingFlags.Public | BindingFlags.Static) + .Single(m => m.Name == "FromProto" + && m.GetParameters() is [{ } p] + && p.ParameterType == wire.GetType()); + + return fromProto.Invoke(null, [wire])!; + } + + private static IEnumerable MappedRecordTypes() => + typeof(SiteCommandDtoMapper) + .GetMethods(BindingFlags.Public | BindingFlags.Static) + .Where(m => m.Name == "ToProto" && m.GetParameters().Length == 1) + .Select(m => m.GetParameters()[0].ParameterType) + .Where(t => !t.IsEnum) + .Distinct(); + + private static IEnumerable CommandSampleTypes() => + SiteCommandSamples.All.Keys.Where(IsCommand); + + /// + /// Reply shapes = the mapper's own classification, plus the synthetic + /// unsubscribe ack, which has no ToProto overload of its own. + /// + private static IEnumerable ReplyTypes() => + SiteCommandSamples.All.Keys.Where(IsReply).Append(typeof(UnsubscribeDebugViewAck)); + + private static bool IsCommand(Type type) => Classifies(type, SiteCommandDtoMapper.GroupOf); + + private static bool IsReply(Type type) => Classifies(type, SiteCommandDtoMapper.GroupOfReply); + + private static bool Classifies(Type type, Func classify) + { + try + { + classify(SiteCommandSamples.All[type][0]); + return true; + } + catch (ArgumentException) + { + return false; + } + } + + private static object Sample(Type type) => SiteCommandSamples.All[type][0]; + + private static object SampleReply(Type type) => + type == typeof(UnsubscribeDebugViewAck) ? UnsubscribeDebugViewAck.Instance : Sample(type); + + private static object PackCommand(object command) => SiteCommandDtoMapper.GroupOf(command) switch + { + SiteCommandGroup.Lifecycle => SiteCommandDtoMapper.ToLifecycleRequest(command), + SiteCommandGroup.OpcUa => SiteCommandDtoMapper.ToOpcUaRequest(command), + SiteCommandGroup.Query => SiteCommandDtoMapper.ToQueryRequest(command), + SiteCommandGroup.Parked => SiteCommandDtoMapper.ToParkedRequest(command), + SiteCommandGroup.Route => SiteCommandDtoMapper.ToRouteRequest(command), + _ => SiteCommandDtoMapper.ToProto((TriggerSiteFailover)command) + }; + + private static object UnpackCommand(object envelope) => envelope switch + { + LifecycleRequest r => SiteCommandDtoMapper.FromLifecycleRequest(r), + OpcUaRequest r => SiteCommandDtoMapper.FromOpcUaRequest(r), + QueryRequest r => SiteCommandDtoMapper.FromQueryRequest(r), + ParkedRequest r => SiteCommandDtoMapper.FromParkedRequest(r), + RouteRequest r => SiteCommandDtoMapper.FromRouteRequest(r), + TriggerSiteFailoverDto d => SiteCommandDtoMapper.FromProto(d), + _ => throw new InvalidOperationException($"Unknown request envelope {envelope.GetType().Name}.") + }; + + private static object PackReply(object reply) => SiteCommandDtoMapper.GroupOfReply(reply) switch + { + SiteCommandGroup.Lifecycle => SiteCommandDtoMapper.ToLifecycleReply(reply), + SiteCommandGroup.OpcUa => SiteCommandDtoMapper.ToOpcUaReply(reply), + SiteCommandGroup.Query => SiteCommandDtoMapper.ToQueryReply(reply), + SiteCommandGroup.Parked => SiteCommandDtoMapper.ToParkedReply(reply), + SiteCommandGroup.Route => SiteCommandDtoMapper.ToRouteReply(reply), + _ => SiteCommandDtoMapper.ToProto((SiteFailoverAck)reply) + }; + + private static object UnpackReply(object envelope) => envelope switch + { + LifecycleReply r => SiteCommandDtoMapper.FromLifecycleReply(r), + OpcUaReply r => SiteCommandDtoMapper.FromOpcUaReply(r), + QueryReply r => SiteCommandDtoMapper.FromQueryReply(r), + ParkedReply r => SiteCommandDtoMapper.FromParkedReply(r), + RouteReply r => SiteCommandDtoMapper.FromRouteReply(r), + SiteFailoverAckDto d => SiteCommandDtoMapper.FromProto(d), + _ => throw new InvalidOperationException($"Unknown reply envelope {envelope.GetType().Name}.") + }; + + private static MessageDescriptor DescriptorFor(string name) => + SiteCommandReflection.Descriptor.MessageTypes.Single(m => m.Name == name); + + private static string OneofCaseName(IMessage envelope) + { + var oneof = envelope.Descriptor.Oneofs[0]; + var field = oneof.Accessor.GetCaseFieldDescriptor(envelope); + Assert.NotNull(field); + return field.PropertyName; + } +} diff --git a/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandSamples.cs b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandSamples.cs new file mode 100644 index 00000000..bb9764a3 --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandSamples.cs @@ -0,0 +1,304 @@ +using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Protocol; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Artifacts; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.DataConnection; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.InboundApi; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Lifecycle; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery; +using ZB.MOM.WW.ScadaBridge.Commons.Messages.Streaming; +using ZB.MOM.WW.ScadaBridge.Commons.Types; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Alarms; +using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Tests; + +/// +/// Golden fixtures for the site-command round-trip suite: for every command, +/// reply and nested type the mapper handles, at least one MAXIMALLY populated +/// sample and one MINIMAL sample (every nullable null, every optional +/// collection empty or absent). +/// +/// +/// +/// The two-sample rule is the point. A single "typical" sample proves only that +/// the happy path survives; the pairs are what catch a dropped optional field or +/// a null/empty collapse — the class of silent data loss the transport +/// round-trip guard exposed in PLAN-05 T8, which per-field unit tests had all +/// missed. +/// +/// +/// drives this table by +/// reflection and FAILS when the mapper gains a type that has no sample here, so +/// the coverage cannot silently drift as commands are added. +/// +/// +internal static class SiteCommandSamples +{ + private static readonly DateTimeOffset T1 = new(2026, 7, 22, 13, 45, 12, 345, TimeSpan.Zero); + private static readonly DateTimeOffset T2 = new(2026, 1, 2, 3, 4, 5, TimeSpan.Zero); + private static readonly DateTime D1 = new(2026, 3, 4, 5, 6, 7, DateTimeKind.Utc); + private static readonly DateTime D2 = new(2027, 3, 4, 5, 6, 7, DateTimeKind.Utc); + private static readonly Guid G1 = Guid.Parse("11111111-2222-3333-4444-555555555555"); + + /// + /// Every CLR type the mapper round-trips, mapped to its golden samples. + /// Enums are excluded — they get their own exhaustive test. + /// + public static IReadOnlyDictionary All { get; } = Build(); + + private static Dictionary Build() + { + var samples = new Dictionary(); + + void Add(params T[] values) where T : notnull => + samples[typeof(T)] = values.Cast().ToArray(); + + // ── Lifecycle commands ── + Add(new RefreshDeploymentCommand( + "dep-1", "Site1.Pump1", "hash-abc", "multi-role", T1, "http://central:5000", "tok-1")); + + Add(new EnableInstanceCommand("cmd-1", "Site1.Pump1", T1)); + Add(new DisableInstanceCommand("cmd-2", "Site1.Pump1", T2)); + Add(new DeleteInstanceCommand("cmd-3", "Site1.Pump1", T1)); + Add(new DeploymentStateQueryRequest("corr-1", "Site1.Pump1", T1)); + + Add( + // Full: every artifact collection populated. + new DeployArtifactsCommand( + "dep-2", + [SharedScript(), new SharedScriptArtifact("s2", "return 2;", null, null)], + [ExternalSystem()], + [new DatabaseConnectionArtifact("db", "Server=x;", 3, TimeSpan.FromSeconds(7.5))], + [new NotificationListArtifact("ops", ["a@x.com", "b@x.com"])], + [DataConnection()], + [Smtp()], + T1), + // Minimal: every collection NULL — must not come back as empty lists. + new DeployArtifactsCommand("dep-3", null, null, null, null, null, null, T2), + // Boundary: every collection present but EMPTY — must not come back null. + new DeployArtifactsCommand("dep-4", [], [], [], [], [], [], T1)); + + Add(SharedScript(), new SharedScriptArtifact("bare", "", null, null)); + Add(ExternalSystem(), new ExternalSystemArtifact("bare", "http://x", "None", null, null, 0)); + Add(new DatabaseConnectionArtifact("db", "Server=x;", 3, TimeSpan.FromMilliseconds(1500)), + new DatabaseConnectionArtifact("db2", "", 0, TimeSpan.Zero)); + Add(new NotificationListArtifact("ops", ["a@x.com"]), new NotificationListArtifact("empty", [])); + Add(DataConnection(), new DataConnectionArtifact("bare", "OpcUa", null, null, 0)); + Add(Smtp(), new SmtpConfigurationArtifact("bare", "smtp", 25, "None", "f@x.com", null, null, null)); + + // ── Lifecycle replies ── + Add(new DeploymentStatusResponse("dep-1", "Site1.Pump1", DeploymentStatus.Success, null, T1), + new DeploymentStatusResponse("dep-1", "Site1.Pump1", DeploymentStatus.Failed, "boom", T2)); + Add(new InstanceLifecycleResponse("cmd-1", "Site1.Pump1", true, null, T1), + new InstanceLifecycleResponse("cmd-1", "Site1.Pump1", false, "nope", T2)); + Add(new DeploymentStateQueryResponse("corr-1", "Site1.Pump1", true, "dep-1", "hash-abc", T1), + new DeploymentStateQueryResponse("corr-1", "Site1.Pump1", false, null, null, T2)); + Add(new ArtifactDeploymentResponse("dep-2", "site-a", true, null, T1), + new ArtifactDeploymentResponse("dep-2", "site-a", false, "handler missing", T2)); + + // ── OPC UA commands ── + Add(new BrowseNodeCommand("conn", "ns=2;s=Root", "cursor-1", "site-a"), + new BrowseNodeCommand("conn", null, null, null)); + Add(new SearchAddressSpaceCommand("conn", "pump", 4, 200, "site-a"), + new SearchAddressSpaceCommand("conn", "", 0, 0, null)); + Add(new ReadTagValuesCommand("conn", ["a", "b"]), new ReadTagValuesCommand("conn", [])); + Add(new VerifyEndpointCommand("conn", "OpcUa", "{\"url\":\"opc.tcp://x\"}", "site-a"), + new VerifyEndpointCommand("conn", "OpcUa", "{}", null)); + Add(new TrustServerCertCommand("conn", "ZGVy", "AABB", "site-a"), + new TrustServerCertCommand("conn", "ZGVy", "AABB", null)); + Add(new ListServerCertsCommand("site-a"), new ListServerCertsCommand(null)); + Add(new RemoveServerCertCommand("AABB", "site-a"), new RemoveServerCertCommand("AABB", null)); + Add(new WriteTagRequest("corr-2", "conn", "ns=2;s=Speed", 42.5d, T1), + new WriteTagRequest("corr-2", "conn", "ns=2;s=Speed", null, T2), + new WriteTagRequest("corr-2", "conn", "ns=2;s=Flag", true, T1), + new WriteTagRequest("corr-2", "conn", "ns=2;s=Name", "manual", T1)); + + // ── OPC UA replies ── + Add(new BrowseNodeResult([Node(), NodeBare()], true, null, "cursor-2"), + new BrowseNodeResult([], false, new BrowseFailure(BrowseFailureKind.Timeout, "timed out"), null)); + Add(Node(), NodeBare()); + Add(new BrowseFailure(BrowseFailureKind.ConnectionNotConnected, "not connected"), + new BrowseFailure(BrowseFailureKind.ServerError, "")); + Add(new SearchAddressSpaceResult([new AddressSpaceMatch(Node(), "/Root/Pump1")], true, null), + new SearchAddressSpaceResult([], false, new BrowseFailure(BrowseFailureKind.NotBrowsable, "no"))); + Add(new AddressSpaceMatch(Node(), "/Root/Pump1"), new AddressSpaceMatch(NodeBare(), "")); + Add(new ReadTagValuesResult([Outcome(), OutcomeFailed()], null), + new ReadTagValuesResult([], new ReadTagValuesFailure(ReadTagValuesFailureKind.ConnectionNotFound, "gone"))); + Add(Outcome(), OutcomeFailed()); + Add(new ReadTagValuesFailure(ReadTagValuesFailureKind.Timeout, "slow"), + new ReadTagValuesFailure(ReadTagValuesFailureKind.ServerError, "")); + Add(new VerifyEndpointResult(true, null, null, null), + new VerifyEndpointResult(false, VerifyFailureKind.UntrustedCertificate, "untrusted", Cert()), + new VerifyEndpointResult(false, VerifyFailureKind.Unreachable, "refused", null)); + Add(Cert()); + Add(new CertTrustResult(true, null, [Trusted(), TrustedRejected()]), + new CertTrustResult(true, null, null), + new CertTrustResult(false, "partial failure", [])); + Add(Trusted(), TrustedRejected()); + Add(new WriteTagResponse("corr-2", true, null, T1), + new WriteTagResponse("corr-2", false, "denied", T2)); + + // ── Query commands ── + Add(new EventLogQueryRequest( + "corr-3", "site-a", T1, T2, "Lifecycle", "Warning", "Site1.Pump1", "restart", "cursor-3", 50, T1), + new EventLogQueryRequest("corr-3", "site-a", null, null, null, null, null, null, null, 25, T2)); + Add(new DebugSnapshotRequest("Site1.Pump1", "corr-4")); + Add(new SubscribeDebugViewRequest("Site1.Pump1", "corr-5")); + Add(new UnsubscribeDebugViewRequest("Site1.Pump1", "corr-6")); + + // ── Query replies ── + Add(new EventLogQueryResponse("corr-3", "site-a", [Entry(), EntryBare()], "cursor-4", true, true, null, T1), + new EventLogQueryResponse("corr-3", "site-a", [], null, false, false, "handler missing", T2)); + Add(Entry(), EntryBare()); + Add(new DebugViewSnapshot("Site1.Pump1", [AttrValue(), AttrValueNull()], [ComputedAlarm(), NativeAlarm()], T1), + new DebugViewSnapshot("Site1.Pump1", [], [], T2, InstanceNotFound: true)); + Add(AttrValue(), AttrValueNull(), AttrValueList()); + Add(ComputedAlarm(), NativeAlarm()); + Add(new AlarmConditionState(true, false, true, AlarmShelveState.TimedShelved, true, 900), + new AlarmConditionState(false, true, null, AlarmShelveState.Unshelved, false, 0)); + + // ── Parked commands ── + Add(new ParkedMessageQueryRequest("corr-7", "site-a", 2, 25, T1)); + Add(new ParkedMessageRetryRequest("corr-8", "site-a", "msg-1", T1)); + Add(new ParkedMessageDiscardRequest("corr-9", "site-a", "msg-1", T2)); + Add(new RetryParkedOperation("corr-10", new TrackedOperationId(G1)), + new RetryParkedOperation("corr-10", default)); + Add(new DiscardParkedOperation("corr-11", new TrackedOperationId(G1)), + new DiscardParkedOperation("corr-11", default)); + + // ── Parked replies ── + Add(new ParkedMessageQueryResponse("corr-7", "site-a", [Parked(), ParkedBare()], 2, 1, 25, true, null, T1), + new ParkedMessageQueryResponse("corr-7", "site-a", [], 0, 1, 25, false, "handler missing", T2)); + Add(Parked(), ParkedBare()); + Add(new ParkedMessageRetryResponse("corr-8", true), + new ParkedMessageRetryResponse("corr-8", false, "not parked")); + Add(new ParkedMessageDiscardResponse("corr-9", true), + new ParkedMessageDiscardResponse("corr-9", false, "not parked")); + Add(new ParkedOperationActionAck("corr-10", true), + new ParkedOperationActionAck("corr-10", false, "handler missing")); + + // ── Route commands ── + Add(new RouteToCallRequest("corr-12", "Site1.Pump1", "Start", Parameters(), T1, G1), + new RouteToCallRequest("corr-12", "Site1.Pump1", "Start", null, T2), + new RouteToCallRequest("corr-12", "Site1.Pump1", "Start", new Dictionary(), T1)); + Add(new RouteToGetAttributesRequest("corr-13", "Site1.Pump1", ["Speed", "Flow"], T1, G1), + new RouteToGetAttributesRequest("corr-13", "Site1.Pump1", [], T2)); + Add(new RouteToSetAttributesRequest( + "corr-14", "Site1.Pump1", new Dictionary { ["Speed"] = "10" }, T1, G1), + new RouteToSetAttributesRequest("corr-14", "Site1.Pump1", new Dictionary(), T2)); + Add(new RouteToWaitForAttributeRequest( + "corr-15", "Site1.Pump1", "Speed", "10", TimeSpan.FromSeconds(30), T1, G1, true), + new RouteToWaitForAttributeRequest( + "corr-15", "Site1.Pump1", "Speed", null, TimeSpan.Zero, T2), + // "" is a legitimate wait target and must NOT collapse to null. + new RouteToWaitForAttributeRequest( + "corr-15", "Site1.Pump1", "Speed", "", TimeSpan.FromMinutes(1), T1)); + + // ── Route replies ── + Add(new RouteToCallResponse("corr-12", true, 17L, null, T1), + new RouteToCallResponse("corr-12", false, null, "script faulted", T2)); + Add(new RouteToGetAttributesResponse("corr-13", Parameters(), true, null, T1), + new RouteToGetAttributesResponse("corr-13", new Dictionary(), false, "no instance", T2)); + Add(new RouteToSetAttributesResponse("corr-14", true, null, T1), + new RouteToSetAttributesResponse("corr-14", false, "locked", T2)); + Add(new RouteToWaitForAttributeResponse("corr-15", true, 10, "Good", false, true, null, T1), + new RouteToWaitForAttributeResponse("corr-15", false, null, null, true, true, null, T2)); + + // ── Failover ── + Add(new TriggerSiteFailover("corr-16", "site-a")); + Add(new SiteFailoverAck("corr-16", true, "akka.tcp://scadabridge@node-b:8081", null), + new SiteFailoverAck("corr-16", false, null, "no standby available")); + + return samples; + } + + private static SharedScriptArtifact SharedScript() => + new("Calc", "return 1;", "{\"p\":\"int\"}", "{\"r\":\"int\"}"); + + private static ExternalSystemArtifact ExternalSystem() => + new("Mes", "https://mes/api", "ApiKey", "{\"key\":\"x\"}", "[{\"name\":\"Post\"}]", 45); + + private static DataConnectionArtifact DataConnection() => + new("Plc1", "OpcUa", "{\"url\":\"opc.tcp://a\"}", "{\"url\":\"opc.tcp://b\"}", 5); + + private static SmtpConfigurationArtifact Smtp() => + new("Default", "smtp.host", 587, "Basic", "from@x.com", "user", "secret", "{\"tenant\":\"t\"}"); + + private static BrowseNode Node() => new("ns=2;s=Pump1.Speed", "Speed", BrowseNodeClass.Variable, false, "Double", -1, true); + + private static BrowseNode NodeBare() => new("ns=2;s=Root", "Root", BrowseNodeClass.Object, true); + + private static TagReadOutcome Outcome() => new("ns=2;s=Speed", true, 12.5d, "Good", T1, null); + + private static TagReadOutcome OutcomeFailed() => new("ns=2;s=Bad", false, null, "Bad", T2, "no such node"); + + private static ServerCertInfo Cert() => new("AABB", "CN=server", "CN=issuer", D1, D2, "ZGVy"); + + private static TrustedCertInfo Trusted() => new("AABB", "CN=server", "CN=issuer", D1, D2, false); + + private static TrustedCertInfo TrustedRejected() => new("CCDD", "CN=other", "CN=issuer", D1, D2, true); + + private static EventLogEntry Entry() => + new(G1.ToString("D"), T1, "Lifecycle", "Warning", "Site1.Pump1", "InstanceActor", "restarted", "{\"n\":1}"); + + private static EventLogEntry EntryBare() => + new(Guid.Empty.ToString("D"), T2, "System", "Info", null, "Host", "started", null); + + private static ParkedMessageEntry Parked() => + new("msg-1", "Mes", "Post", "500 from server", 7, T1, T2, 10, StoreAndForwardCategory.CachedDbWrite, "Site1.Pump1"); + + private static ParkedMessageEntry ParkedBare() => + new("msg-2", "Mes", "Post", "", 0, T2, T2); + + private static AttributeValueChanged AttrValue() => + new("Site1.Pump1", "Pump1.Speed", "Speed", 12.5d, "Good", T1); + + private static AttributeValueChanged AttrValueNull() => + new("Site1.Pump1", "Pump1.Speed", "Speed", null, "Bad", T2); + + private static AttributeValueChanged AttrValueList() => + new("Site1.Pump1", "Pump1.Trend", "Trend", new List { 1, 2.5d, "x", null }, "Good", T1); + + /// A computed alarm: Condition left implicit, which is the common case. + private static AlarmStateChanged ComputedAlarm() => + new("Site1.Pump1", "HighSpeed", AlarmState.Active, 700, T1) + { + Level = AlarmLevel.HighHigh, + Message = "Speed critically high" + }; + + /// A mirrored native alarm: every native enrichment field populated, Condition explicit. + private static AlarmStateChanged NativeAlarm() => + new("Site1.Pump1", "Tank01.Level.HiHi", AlarmState.Active, 850, T2) + { + Level = AlarmLevel.None, + Message = "Level high", + Kind = AlarmKind.NativeOpcUa, + Condition = new AlarmConditionState(true, false, false, AlarmShelveState.OneShotShelved, true, 850), + SourceReference = "Tank01.Level.HiHi", + AlarmTypeName = "AnalogLimitAlarm.HiHi", + Category = "Process", + OperatorUser = "multi-role", + OperatorComment = "ack'd at panel", + OriginalRaiseTime = T1, + CurrentValue = "91.2", + LimitValue = "90.0", + NativeSourceCanonicalName = "Tank01.TankAlarms", + IsConfiguredPlaceholder = true + }; + + private static Dictionary Parameters() => new() + { + ["count"] = 3, + ["ratio"] = 1.25d, + ["name"] = "batch-1", + ["enabled"] = true, + ["missing"] = null, + ["when"] = T1, + ["id"] = G1, + ["items"] = new List { 1L, "two", null }, + ["nested"] = new Dictionary { ["inner"] = 5f } + }; +} diff --git a/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/StructuralEquality.cs b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/StructuralEquality.cs new file mode 100644 index 00000000..995929bf --- /dev/null +++ b/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/StructuralEquality.cs @@ -0,0 +1,157 @@ +using System.Collections; +using System.Reflection; +using System.Text.Json; + +namespace ZB.MOM.WW.ScadaBridge.Communication.Tests; + +/// +/// Structural deep-equality assertion for the site-command round-trip goldens. +/// +/// +/// +/// Record equality is NOT usable here. A C# record's generated Equals +/// compares members with EqualityComparer<T>.Default, which for +/// IReadOnlyList<T> / IReadOnlyDictionary<,> members +/// degrades to reference equality — so Assert.Equal(dto, roundTripped) +/// would fail on every collection-bearing message even when the mapper is +/// perfect, and (worse) would pass vacuously nowhere useful. This walker +/// compares by shape instead: dictionaries by key, sequences element-wise, and +/// everything else property-by-property down to leaf values. +/// +/// +/// The failure message carries the full property path, so a dropped field +/// reports as e.g. DeployArtifactsCommand.ExternalSystems[0].TimeoutSeconds +/// rather than an opaque "objects differ". +/// +/// +internal static class StructuralEquality +{ + /// Asserts two object graphs are structurally identical. + /// The original value. + /// The value that came back through the mapper. + /// Name used as the root of the reported property path. + public static void AssertDeepEqual(object? expected, object? actual, string rootName) + => Compare(expected, actual, rootName); + + private static void Compare(object? expected, object? actual, string path) + { + if (expected is null && actual is null) + { + return; + } + + if (expected is null || actual is null) + { + Assert.Fail($"{path}: expected {Describe(expected)} but got {Describe(actual)}."); + return; + } + + // JsonElement is the documented lossy escape hatch of LooseValueCodec; it + // has no useful Equals, so compare the canonical JSON text. + if (expected is JsonElement expectedJson && actual is JsonElement actualJson) + { + Assert.Equal(expectedJson.GetRawText(), actualJson.GetRawText()); + return; + } + + // Collections are compared by CONTENT, not by concrete container type. + // Members are declared IReadOnlyList/IReadOnlyDictionary<,>, so the + // backing type (a collection-expression array here, a List out of the + // mapper) is not part of the contract. Element and value types below are + // still compared strictly. + if (expected is not string && actual is not string) + { + if (expected is IDictionary expectedMap && actual is IDictionary actualMap) + { + CompareDictionaries(expectedMap, actualMap, path); + return; + } + + if (expected is IEnumerable expectedSeq && actual is IEnumerable actualSeq) + { + CompareSequences(expectedSeq, actualSeq, path); + return; + } + } + + var expectedType = expected.GetType(); + var actualType = actual.GetType(); + + if (expectedType != actualType) + { + Assert.Fail( + $"{path}: type changed across the round trip — expected {expectedType.Name}, got {actualType.Name}."); + return; + } + + if (IsLeaf(expectedType)) + { + Assert.True( + Equals(expected, actual), + $"{path}: expected '{expected}' but got '{actual}'."); + return; + } + + CompareProperties(expected, actual, expectedType, path); + } + + private static void CompareDictionaries(IDictionary expected, IDictionary actual, string path) + { + Assert.True( + expected.Count == actual.Count, + $"{path}: entry count changed — expected {expected.Count}, got {actual.Count}."); + + foreach (DictionaryEntry entry in expected) + { + Assert.True( + actual.Contains(entry.Key), + $"{path}: key '{entry.Key}' is missing after the round trip."); + Compare(entry.Value, actual[entry.Key], $"{path}['{entry.Key}']"); + } + } + + private static void CompareSequences(IEnumerable expected, IEnumerable actual, string path) + { + var expectedItems = expected.Cast().ToList(); + var actualItems = actual.Cast().ToList(); + + Assert.True( + expectedItems.Count == actualItems.Count, + $"{path}: element count changed — expected {expectedItems.Count}, got {actualItems.Count}."); + + for (var i = 0; i < expectedItems.Count; i++) + { + Compare(expectedItems[i], actualItems[i], $"{path}[{i}]"); + } + } + + private static void CompareProperties(object expected, object actual, Type type, string path) + { + var properties = type + .GetProperties(BindingFlags.Public | BindingFlags.Instance) + .Where(p => p.CanRead && p.GetIndexParameters().Length == 0) + .ToList(); + + Assert.True(properties.Count > 0, $"{path}: {type.Name} exposes no readable properties to compare."); + + foreach (var property in properties) + { + Compare(property.GetValue(expected), property.GetValue(actual), $"{path}.{property.Name}"); + } + } + + private static bool IsLeaf(Type type) => + type.IsPrimitive + || type.IsEnum + || type == typeof(string) + || type == typeof(decimal) + || type == typeof(DateTime) + || type == typeof(DateTimeOffset) + || type == typeof(TimeSpan) + || type == typeof(Guid) + // Value types with no collection members (e.g. TrackedOperationId) have a + // correct structural Equals of their own. + || (type.IsValueType && !type.IsGenericType); + + private static string Describe(object? value) => value is null ? "" : $"{value.GetType().Name}('{value}')"; +}