From 59b13d317bd49f11b029c26ac231487e042d6f3c Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Wed, 22 Jul 2026 18:39:54 -0400 Subject: [PATCH] =?UTF-8?q?feat(grpc):=20T1B.1=20=E2=80=94=20site=5Fcomman?= =?UTF-8?q?d.proto=20+=20SiteCommandDtoMapper=20+=20round-trip=20goldens?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Phase 1B's contract slice: the wire shape and the canonical translation for the 28 central→site commands that leave ClusterClient. No behaviour changes yet — SiteCommunicationActor and CentralCommunicationActor are untouched; the dispatcher refactor (T1B.2) and the central transport seam (T1B.3) consume this. Protos/site_command.proto (package scadabridge.sitecommand.v1, service SiteCommandService): six domain RPCs, each with a `oneof` request/reply envelope. The grouping is what carries deadline policy — every command inside a group shares a CommunicationOptions timeout class today, so one RPC per group keeps the deadline choice in one place on the client and one dispatch switch on the server, while the oneof keeps each command individually typed: ExecuteLifecycle(6) · ExecuteOpcUa(8) · ExecuteQuery(4) · ExecuteParked(5) · ExecuteRoute(4) · TriggerFailover(1). IntegrationCallRequest — the 29th entry on SiteCommunicationActor's receive table — is deliberately excluded as dead code (2026-07-22-integration-call-routing-is-dead-code.md). Contract decisions worth knowing: - Nullable COLLECTIONS ride in per-collection wrapper messages (DeployArtifactsCommand's six artifact lists, CertTrustResult.Certs, RouteToCallRequest.Parameters). proto3 repeated/map collapses null into empty, and that distinction is live at the site — the same silent-data-loss class the transport round-trip guard exposed in PLAN-05 T8. Goldens cover null, empty and populated for each. - Nullable strings use the empty-string-means-null convention already set by AuditEventDtoMapper, with ONE exception: RouteToWaitForAttributeRequest's TargetValueEncoded, where "wait for the empty string" is a real target, so it carries a StringValue wrapper. Both behaviours are asserted, not assumed. - Nullable enums ride in one-field messages (proto3 enums have no presence and no stock wrapper). Enum translation is an explicit switch in both directions — never by ordinal — so reordering a C# enum cannot re-map the wire; every wire enum reserves 0 for _UNSPECIFIED and decodes to a documented safe default rather than faulting a command from a version-skewed peer. - New LooseValueCodec carries the surviving `object?` members (script params and return values, attribute values, tag read/write values) as a type-tagged union so a boxed value keeps its runtime CLR type, as it does today under Akka's type-preserving JSON serializer. Dates ride as invariant round-trip strings, not Timestamp, which would silently normalise away DateTime.Kind and DateTimeOffset.Offset. Lists/maps recurse; anything outside the tagged set falls back to JSON and is documented as CLR-type-lossy. - DebugViewSnapshot gets its own full-fidelity alarm/attribute messages rather than reusing sitestream's AlarmStateUpdate, which flattens values to display strings — right for a live stream, lossy for a snapshot the UI treats as authoritative. The encoder omits an AlarmStateChanged.Condition that already equals the record's derived default, so computed alarms round-trip exactly (record equality compares the nullable backing field, not the property). Tests are reflection-driven so the coverage cannot drift: the round-trip theory enumerates the mapper's own ToProto overloads, the envelope guards enumerate the generated oneof descriptors, and a missing golden fails the build. 216 new tests green (Communication 532 total, Commons 684 total, solution build 0/0). Codegen is checked in under SiteCommandGrpc/ per the sitestream recipe; the ItemGroup stays commented out (an active one segfaults protoc in the linux_arm64 Docker image). docker/regen-proto.sh now handles every proto in that ItemGroup instead of just sitestream, and re-comments idempotently. --- docker/regen-proto.sh | 27 +- .../2026-07-22-clusterclient-to-grpc-plan.md | 4 +- .../Grpc/LooseValueCodec.cs | 219 + .../Grpc/SiteCommandDtoMapper.cs | 3040 ++ .../Grpc/SiteCommandGroup.cs | 33 + .../Protos/site_command.proto | 857 + .../SiteCommandGrpc/SiteCommand.cs | 31813 ++++++++++++++++ .../SiteCommandGrpc/SiteCommandGrpc.cs | 559 + ...ZB.MOM.WW.ScadaBridge.Communication.csproj | 31 +- .../LooseValueCodecTests.cs | 153 + .../SiteCommandDtoMapperGoldenTests.cs | 569 + .../SiteCommandSamples.cs | 304 + .../StructuralEquality.cs | 157 + 13 files changed, 37742 insertions(+), 24 deletions(-) create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/LooseValueCodec.cs create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandDtoMapper.cs create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandGroup.cs create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/Protos/site_command.proto create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommand.cs create mode 100644 src/ZB.MOM.WW.ScadaBridge.Communication/SiteCommandGrpc/SiteCommandGrpc.cs create mode 100644 tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/LooseValueCodecTests.cs create mode 100644 tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandDtoMapperGoldenTests.cs create mode 100644 tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/SiteCommandSamples.cs create mode 100644 tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/StructuralEquality.cs 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}')"; +}