diff --git a/akka-http-core/src/test/scala/akka/http/impl/util/One2OneBidiFlowSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/util/One2OneBidiFlowSpec.scala index 31f2bd24de..75d5739c41 100644 --- a/akka-http-core/src/test/scala/akka/http/impl/util/One2OneBidiFlowSpec.scala +++ b/akka-http-core/src/test/scala/akka/http/impl/util/One2OneBidiFlowSpec.scala @@ -114,7 +114,7 @@ class One2OneBidiFlowSpec extends AkkaSpec { out.sendComplete() // To please assertAllStagesStopped } - "not pull when input is closed before surpressed pull can be acted on" in assertAllStagesStopped { + "not pull when input is closed before surpressed pull can be acted on" in assertAllStagesStopped { val in = TestPublisher.probe[Int]() val out = TestSubscriber.probe[Int]() val wrappedIn = TestSubscriber.probe[Int]() diff --git a/akka-remote/src/main/java/akka/remote/ContainerFormats.java b/akka-remote/src/main/java/akka/remote/ContainerFormats.java index 677071914c..c22fd48253 100644 --- a/akka-remote/src/main/java/akka/remote/ContainerFormats.java +++ b/akka-remote/src/main/java/akka/remote/ContainerFormats.java @@ -4563,6 +4563,410 @@ public final class ContainerFormats { // @@protoc_insertion_point(class_scope:Payload) } + public interface WatcherHeartbeatResponseOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required uint64 uid = 1; + /** + * required uint64 uid = 1; + */ + boolean hasUid(); + /** + * required uint64 uid = 1; + */ + long getUid(); + } + /** + * Protobuf type {@code WatcherHeartbeatResponse} + */ + public static final class WatcherHeartbeatResponse extends + akka.protobuf.GeneratedMessage + implements WatcherHeartbeatResponseOrBuilder { + // Use WatcherHeartbeatResponse.newBuilder() to construct. + private WatcherHeartbeatResponse(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private WatcherHeartbeatResponse(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final WatcherHeartbeatResponse defaultInstance; + public static WatcherHeartbeatResponse getDefaultInstance() { + return defaultInstance; + } + + public WatcherHeartbeatResponse getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private WatcherHeartbeatResponse( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + uid_ = input.readUInt64(); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_WatcherHeartbeatResponse_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_WatcherHeartbeatResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.WatcherHeartbeatResponse.class, akka.remote.ContainerFormats.WatcherHeartbeatResponse.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public WatcherHeartbeatResponse parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new WatcherHeartbeatResponse(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required uint64 uid = 1; + public static final int UID_FIELD_NUMBER = 1; + private long uid_; + /** + * required uint64 uid = 1; + */ + public boolean hasUid() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required uint64 uid = 1; + */ + public long getUid() { + return uid_; + } + + private void initFields() { + uid_ = 0L; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasUid()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeUInt64(1, uid_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeUInt64Size(1, uid_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.WatcherHeartbeatResponse parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.ContainerFormats.WatcherHeartbeatResponse prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code WatcherHeartbeatResponse} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.ContainerFormats.WatcherHeartbeatResponseOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_WatcherHeartbeatResponse_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_WatcherHeartbeatResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.WatcherHeartbeatResponse.class, akka.remote.ContainerFormats.WatcherHeartbeatResponse.Builder.class); + } + + // Construct using akka.remote.ContainerFormats.WatcherHeartbeatResponse.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + uid_ = 0L; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.ContainerFormats.internal_static_WatcherHeartbeatResponse_descriptor; + } + + public akka.remote.ContainerFormats.WatcherHeartbeatResponse getDefaultInstanceForType() { + return akka.remote.ContainerFormats.WatcherHeartbeatResponse.getDefaultInstance(); + } + + public akka.remote.ContainerFormats.WatcherHeartbeatResponse build() { + akka.remote.ContainerFormats.WatcherHeartbeatResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.ContainerFormats.WatcherHeartbeatResponse buildPartial() { + akka.remote.ContainerFormats.WatcherHeartbeatResponse result = new akka.remote.ContainerFormats.WatcherHeartbeatResponse(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.uid_ = uid_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.ContainerFormats.WatcherHeartbeatResponse) { + return mergeFrom((akka.remote.ContainerFormats.WatcherHeartbeatResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.ContainerFormats.WatcherHeartbeatResponse other) { + if (other == akka.remote.ContainerFormats.WatcherHeartbeatResponse.getDefaultInstance()) return this; + if (other.hasUid()) { + setUid(other.getUid()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasUid()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.ContainerFormats.WatcherHeartbeatResponse parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.ContainerFormats.WatcherHeartbeatResponse) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required uint64 uid = 1; + private long uid_ ; + /** + * required uint64 uid = 1; + */ + public boolean hasUid() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required uint64 uid = 1; + */ + public long getUid() { + return uid_; + } + /** + * required uint64 uid = 1; + */ + public Builder setUid(long value) { + bitField0_ |= 0x00000001; + uid_ = value; + onChanged(); + return this; + } + /** + * required uint64 uid = 1; + */ + public Builder clearUid() { + bitField0_ = (bitField0_ & ~0x00000001); + uid_ = 0L; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:WatcherHeartbeatResponse) + } + + static { + defaultInstance = new WatcherHeartbeatResponse(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:WatcherHeartbeatResponse) + } + public interface ThrowableOrBuilder extends akka.protobuf.MessageOrBuilder { @@ -5776,6 +6180,897 @@ public final class ContainerFormats { // @@protoc_insertion_point(class_scope:Throwable) } + public interface ActorInitializationExceptionOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // optional .ActorRef actor = 1; + /** + * optional .ActorRef actor = 1; + */ + boolean hasActor(); + /** + * optional .ActorRef actor = 1; + */ + akka.remote.ContainerFormats.ActorRef getActor(); + /** + * optional .ActorRef actor = 1; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder(); + + // required string message = 2; + /** + * required string message = 2; + */ + boolean hasMessage(); + /** + * required string message = 2; + */ + java.lang.String getMessage(); + /** + * required string message = 2; + */ + akka.protobuf.ByteString + getMessageBytes(); + + // required .Payload cause = 3; + /** + * required .Payload cause = 3; + */ + boolean hasCause(); + /** + * required .Payload cause = 3; + */ + akka.remote.ContainerFormats.Payload getCause(); + /** + * required .Payload cause = 3; + */ + akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder(); + } + /** + * Protobuf type {@code ActorInitializationException} + */ + public static final class ActorInitializationException extends + akka.protobuf.GeneratedMessage + implements ActorInitializationExceptionOrBuilder { + // Use ActorInitializationException.newBuilder() to construct. + private ActorInitializationException(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private ActorInitializationException(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final ActorInitializationException defaultInstance; + public static ActorInitializationException getDefaultInstance() { + return defaultInstance; + } + + public ActorInitializationException getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ActorInitializationException( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = actor_.toBuilder(); + } + actor_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(actor_); + actor_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + bitField0_ |= 0x00000002; + message_ = input.readBytes(); + break; + } + case 26: { + akka.remote.ContainerFormats.Payload.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = cause_.toBuilder(); + } + cause_ = input.readMessage(akka.remote.ContainerFormats.Payload.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(cause_); + cause_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_ActorInitializationException_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_ActorInitializationException_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.ActorInitializationException.class, akka.remote.ContainerFormats.ActorInitializationException.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public ActorInitializationException parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new ActorInitializationException(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional .ActorRef actor = 1; + public static final int ACTOR_FIELD_NUMBER = 1; + private akka.remote.ContainerFormats.ActorRef actor_; + /** + * optional .ActorRef actor = 1; + */ + public boolean hasActor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef getActor() { + return actor_; + } + /** + * optional .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder() { + return actor_; + } + + // required string message = 2; + public static final int MESSAGE_FIELD_NUMBER = 2; + private java.lang.Object message_; + /** + * required string message = 2; + */ + public boolean hasMessage() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string message = 2; + */ + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + message_ = s; + } + return s; + } + } + /** + * required string message = 2; + */ + public akka.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // required .Payload cause = 3; + public static final int CAUSE_FIELD_NUMBER = 3; + private akka.remote.ContainerFormats.Payload cause_; + /** + * required .Payload cause = 3; + */ + public boolean hasCause() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload getCause() { + return cause_; + } + /** + * required .Payload cause = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder() { + return cause_; + } + + private void initFields() { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + message_ = ""; + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasMessage()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCause()) { + memoizedIsInitialized = 0; + return false; + } + if (hasActor()) { + if (!getActor().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getCause().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, actor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getMessageBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, cause_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(1, actor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(2, getMessageBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(3, cause_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.ActorInitializationException parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.ContainerFormats.ActorInitializationException prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ActorInitializationException} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.ContainerFormats.ActorInitializationExceptionOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_ActorInitializationException_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_ActorInitializationException_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.ActorInitializationException.class, akka.remote.ContainerFormats.ActorInitializationException.Builder.class); + } + + // Construct using akka.remote.ContainerFormats.ActorInitializationException.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getActorFieldBuilder(); + getCauseFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (actorBuilder_ == null) { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + actorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + message_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + if (causeBuilder_ == null) { + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + } else { + causeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.ContainerFormats.internal_static_ActorInitializationException_descriptor; + } + + public akka.remote.ContainerFormats.ActorInitializationException getDefaultInstanceForType() { + return akka.remote.ContainerFormats.ActorInitializationException.getDefaultInstance(); + } + + public akka.remote.ContainerFormats.ActorInitializationException build() { + akka.remote.ContainerFormats.ActorInitializationException result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.ContainerFormats.ActorInitializationException buildPartial() { + akka.remote.ContainerFormats.ActorInitializationException result = new akka.remote.ContainerFormats.ActorInitializationException(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (actorBuilder_ == null) { + result.actor_ = actor_; + } else { + result.actor_ = actorBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.message_ = message_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (causeBuilder_ == null) { + result.cause_ = cause_; + } else { + result.cause_ = causeBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.ContainerFormats.ActorInitializationException) { + return mergeFrom((akka.remote.ContainerFormats.ActorInitializationException)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.ContainerFormats.ActorInitializationException other) { + if (other == akka.remote.ContainerFormats.ActorInitializationException.getDefaultInstance()) return this; + if (other.hasActor()) { + mergeActor(other.getActor()); + } + if (other.hasMessage()) { + bitField0_ |= 0x00000002; + message_ = other.message_; + onChanged(); + } + if (other.hasCause()) { + mergeCause(other.getCause()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasMessage()) { + + return false; + } + if (!hasCause()) { + + return false; + } + if (hasActor()) { + if (!getActor().isInitialized()) { + + return false; + } + } + if (!getCause().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.ContainerFormats.ActorInitializationException parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.ContainerFormats.ActorInitializationException) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional .ActorRef actor = 1; + private akka.remote.ContainerFormats.ActorRef actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> actorBuilder_; + /** + * optional .ActorRef actor = 1; + */ + public boolean hasActor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef getActor() { + if (actorBuilder_ == null) { + return actor_; + } else { + return actorBuilder_.getMessage(); + } + } + /** + * optional .ActorRef actor = 1; + */ + public Builder setActor(akka.remote.ContainerFormats.ActorRef value) { + if (actorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + actor_ = value; + onChanged(); + } else { + actorBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .ActorRef actor = 1; + */ + public Builder setActor( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (actorBuilder_ == null) { + actor_ = builderForValue.build(); + onChanged(); + } else { + actorBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .ActorRef actor = 1; + */ + public Builder mergeActor(akka.remote.ContainerFormats.ActorRef value) { + if (actorBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + actor_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + actor_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(actor_).mergeFrom(value).buildPartial(); + } else { + actor_ = value; + } + onChanged(); + } else { + actorBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * optional .ActorRef actor = 1; + */ + public Builder clearActor() { + if (actorBuilder_ == null) { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + actorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * optional .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getActorBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getActorFieldBuilder().getBuilder(); + } + /** + * optional .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder() { + if (actorBuilder_ != null) { + return actorBuilder_.getMessageOrBuilder(); + } else { + return actor_; + } + } + /** + * optional .ActorRef actor = 1; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getActorFieldBuilder() { + if (actorBuilder_ == null) { + actorBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + actor_, + getParentForChildren(), + isClean()); + actor_ = null; + } + return actorBuilder_; + } + + // required string message = 2; + private java.lang.Object message_ = ""; + /** + * required string message = 2; + */ + public boolean hasMessage() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string message = 2; + */ + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + message_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string message = 2; + */ + public akka.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * required string message = 2; + */ + public Builder setMessage( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + message_ = value; + onChanged(); + return this; + } + /** + * required string message = 2; + */ + public Builder clearMessage() { + bitField0_ = (bitField0_ & ~0x00000002); + message_ = getDefaultInstance().getMessage(); + onChanged(); + return this; + } + /** + * required string message = 2; + */ + public Builder setMessageBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + message_ = value; + onChanged(); + return this; + } + + // required .Payload cause = 3; + private akka.remote.ContainerFormats.Payload cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> causeBuilder_; + /** + * required .Payload cause = 3; + */ + public boolean hasCause() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload getCause() { + if (causeBuilder_ == null) { + return cause_; + } else { + return causeBuilder_.getMessage(); + } + } + /** + * required .Payload cause = 3; + */ + public Builder setCause(akka.remote.ContainerFormats.Payload value) { + if (causeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + cause_ = value; + onChanged(); + } else { + causeBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * required .Payload cause = 3; + */ + public Builder setCause( + akka.remote.ContainerFormats.Payload.Builder builderForValue) { + if (causeBuilder_ == null) { + cause_ = builderForValue.build(); + onChanged(); + } else { + causeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * required .Payload cause = 3; + */ + public Builder mergeCause(akka.remote.ContainerFormats.Payload value) { + if (causeBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + cause_ != akka.remote.ContainerFormats.Payload.getDefaultInstance()) { + cause_ = + akka.remote.ContainerFormats.Payload.newBuilder(cause_).mergeFrom(value).buildPartial(); + } else { + cause_ = value; + } + onChanged(); + } else { + causeBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * required .Payload cause = 3; + */ + public Builder clearCause() { + if (causeBuilder_ == null) { + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + onChanged(); + } else { + causeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * required .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload.Builder getCauseBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCauseFieldBuilder().getBuilder(); + } + /** + * required .Payload cause = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder() { + if (causeBuilder_ != null) { + return causeBuilder_.getMessageOrBuilder(); + } else { + return cause_; + } + } + /** + * required .Payload cause = 3; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> + getCauseFieldBuilder() { + if (causeBuilder_ == null) { + causeBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder>( + cause_, + getParentForChildren(), + isClean()); + cause_ = null; + } + return causeBuilder_; + } + + // @@protoc_insertion_point(builder_scope:ActorInitializationException) + } + + static { + defaultInstance = new ActorInitializationException(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ActorInitializationException) + } + public interface StackTraceElementOrBuilder extends akka.protobuf.MessageOrBuilder { @@ -6707,11 +8002,21 @@ public final class ContainerFormats { private static akka.protobuf.GeneratedMessage.FieldAccessorTable internal_static_Payload_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_WatcherHeartbeatResponse_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_WatcherHeartbeatResponse_fieldAccessorTable; private static akka.protobuf.Descriptors.Descriptor internal_static_Throwable_descriptor; private static akka.protobuf.GeneratedMessage.FieldAccessorTable internal_static_Throwable_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_ActorInitializationException_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ActorInitializationException_fieldAccessorTable; private static akka.protobuf.Descriptors.Descriptor internal_static_StackTraceElement_descriptor; private static @@ -6738,14 +8043,17 @@ public final class ContainerFormats { "path\030\001 \002(\t\"!\n\006Option\022\027\n\005value\030\001 \001(\0132\010.Pa", "yload\"Q\n\007Payload\022\027\n\017enclosedMessage\030\001 \002(" + "\014\022\024\n\014serializerId\030\002 \002(\005\022\027\n\017messageManife" + - "st\030\004 \001(\014\"p\n\tThrowable\022\021\n\tclassName\030\001 \002(\t" + - "\022\017\n\007message\030\002 \001(\t\022\027\n\005cause\030\003 \001(\0132\010.Paylo" + - "ad\022&\n\nstackTrace\030\004 \003(\0132\022.StackTraceEleme" + - "nt\"`\n\021StackTraceElement\022\021\n\tclassName\030\001 \002" + - "(\t\022\022\n\nmethodName\030\002 \002(\t\022\020\n\010fileName\030\003 \002(\t" + - "\022\022\n\nlineNumber\030\004 \002(\005*<\n\013PatternType\022\n\n\006P" + - "ARENT\020\000\022\016\n\nCHILD_NAME\020\001\022\021\n\rCHILD_PATTERN" + - "\020\002B\017\n\013akka.remoteH\001" + "st\030\004 \001(\014\"\'\n\030WatcherHeartbeatResponse\022\013\n\003" + + "uid\030\001 \002(\004\"p\n\tThrowable\022\021\n\tclassName\030\001 \002(" + + "\t\022\017\n\007message\030\002 \001(\t\022\027\n\005cause\030\003 \001(\0132\010.Payl" + + "oad\022&\n\nstackTrace\030\004 \003(\0132\022.StackTraceElem" + + "ent\"b\n\034ActorInitializationException\022\030\n\005a" + + "ctor\030\001 \001(\0132\t.ActorRef\022\017\n\007message\030\002 \002(\t\022\027" + + "\n\005cause\030\003 \002(\0132\010.Payload\"`\n\021StackTraceEle" + + "ment\022\021\n\tclassName\030\001 \002(\t\022\022\n\nmethodName\030\002 ", + "\002(\t\022\020\n\010fileName\030\003 \002(\t\022\022\n\nlineNumber\030\004 \002(" + + "\005*<\n\013PatternType\022\n\n\006PARENT\020\000\022\016\n\nCHILD_NA" + + "ME\020\001\022\021\n\rCHILD_PATTERN\020\002B\017\n\013akka.remoteH\001" }; akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -6794,14 +8102,26 @@ public final class ContainerFormats { akka.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_Payload_descriptor, new java.lang.String[] { "EnclosedMessage", "SerializerId", "MessageManifest", }); - internal_static_Throwable_descriptor = + internal_static_WatcherHeartbeatResponse_descriptor = getDescriptor().getMessageTypes().get(7); + internal_static_WatcherHeartbeatResponse_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_WatcherHeartbeatResponse_descriptor, + new java.lang.String[] { "Uid", }); + internal_static_Throwable_descriptor = + getDescriptor().getMessageTypes().get(8); internal_static_Throwable_fieldAccessorTable = new akka.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_Throwable_descriptor, new java.lang.String[] { "ClassName", "Message", "Cause", "StackTrace", }); + internal_static_ActorInitializationException_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_ActorInitializationException_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ActorInitializationException_descriptor, + new java.lang.String[] { "Actor", "Message", "Cause", }); internal_static_StackTraceElement_descriptor = - getDescriptor().getMessageTypes().get(8); + getDescriptor().getMessageTypes().get(10); internal_static_StackTraceElement_fieldAccessorTable = new akka.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_StackTraceElement_descriptor, diff --git a/akka-remote/src/main/java/akka/remote/SystemMessageFormats.java b/akka-remote/src/main/java/akka/remote/SystemMessageFormats.java new file mode 100644 index 0000000000..122d30729a --- /dev/null +++ b/akka-remote/src/main/java/akka/remote/SystemMessageFormats.java @@ -0,0 +1,4354 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: SystemMessageFormats.proto + +package akka.remote; + +public final class SystemMessageFormats { + private SystemMessageFormats() {} + public static void registerAllExtensions( + akka.protobuf.ExtensionRegistry registry) { + } + public interface SystemMessageOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required .SystemMessage.Type type = 1; + /** + * required .SystemMessage.Type type = 1; + */ + boolean hasType(); + /** + * required .SystemMessage.Type type = 1; + */ + akka.remote.SystemMessageFormats.SystemMessage.Type getType(); + + // optional .WatchData watchData = 2; + /** + * optional .WatchData watchData = 2; + */ + boolean hasWatchData(); + /** + * optional .WatchData watchData = 2; + */ + akka.remote.SystemMessageFormats.WatchData getWatchData(); + /** + * optional .WatchData watchData = 2; + */ + akka.remote.SystemMessageFormats.WatchDataOrBuilder getWatchDataOrBuilder(); + + // optional .Payload causeData = 3; + /** + * optional .Payload causeData = 3; + */ + boolean hasCauseData(); + /** + * optional .Payload causeData = 3; + */ + akka.remote.ContainerFormats.Payload getCauseData(); + /** + * optional .Payload causeData = 3; + */ + akka.remote.ContainerFormats.PayloadOrBuilder getCauseDataOrBuilder(); + + // optional .SuperviseData superviseData = 5; + /** + * optional .SuperviseData superviseData = 5; + */ + boolean hasSuperviseData(); + /** + * optional .SuperviseData superviseData = 5; + */ + akka.remote.SystemMessageFormats.SuperviseData getSuperviseData(); + /** + * optional .SuperviseData superviseData = 5; + */ + akka.remote.SystemMessageFormats.SuperviseDataOrBuilder getSuperviseDataOrBuilder(); + + // optional .FailedData failedData = 6; + /** + * optional .FailedData failedData = 6; + */ + boolean hasFailedData(); + /** + * optional .FailedData failedData = 6; + */ + akka.remote.SystemMessageFormats.FailedData getFailedData(); + /** + * optional .FailedData failedData = 6; + */ + akka.remote.SystemMessageFormats.FailedDataOrBuilder getFailedDataOrBuilder(); + + // optional .DeathWatchNotificationData dwNotificationData = 7; + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + boolean hasDwNotificationData(); + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + akka.remote.SystemMessageFormats.DeathWatchNotificationData getDwNotificationData(); + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder getDwNotificationDataOrBuilder(); + } + /** + * Protobuf type {@code SystemMessage} + */ + public static final class SystemMessage extends + akka.protobuf.GeneratedMessage + implements SystemMessageOrBuilder { + // Use SystemMessage.newBuilder() to construct. + private SystemMessage(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private SystemMessage(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final SystemMessage defaultInstance; + public static SystemMessage getDefaultInstance() { + return defaultInstance; + } + + public SystemMessage getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private SystemMessage( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + akka.remote.SystemMessageFormats.SystemMessage.Type value = akka.remote.SystemMessageFormats.SystemMessage.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = value; + } + break; + } + case 18: { + akka.remote.SystemMessageFormats.WatchData.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = watchData_.toBuilder(); + } + watchData_ = input.readMessage(akka.remote.SystemMessageFormats.WatchData.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(watchData_); + watchData_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + akka.remote.ContainerFormats.Payload.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = causeData_.toBuilder(); + } + causeData_ = input.readMessage(akka.remote.ContainerFormats.Payload.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(causeData_); + causeData_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 42: { + akka.remote.SystemMessageFormats.SuperviseData.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = superviseData_.toBuilder(); + } + superviseData_ = input.readMessage(akka.remote.SystemMessageFormats.SuperviseData.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(superviseData_); + superviseData_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 50: { + akka.remote.SystemMessageFormats.FailedData.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = failedData_.toBuilder(); + } + failedData_ = input.readMessage(akka.remote.SystemMessageFormats.FailedData.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(failedData_); + failedData_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 58: { + akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + subBuilder = dwNotificationData_.toBuilder(); + } + dwNotificationData_ = input.readMessage(akka.remote.SystemMessageFormats.DeathWatchNotificationData.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(dwNotificationData_); + dwNotificationData_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_SystemMessage_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_SystemMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.SystemMessage.class, akka.remote.SystemMessageFormats.SystemMessage.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public SystemMessage parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new SystemMessage(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + /** + * Protobuf enum {@code SystemMessage.Type} + */ + public enum Type + implements akka.protobuf.ProtocolMessageEnum { + /** + * CREATE = 0; + */ + CREATE(0, 0), + /** + * RECREATE = 1; + */ + RECREATE(1, 1), + /** + * SUSPEND = 2; + */ + SUSPEND(2, 2), + /** + * RESUME = 3; + */ + RESUME(3, 3), + /** + * TERMINATE = 4; + */ + TERMINATE(4, 4), + /** + * SUPERVISE = 5; + */ + SUPERVISE(5, 5), + /** + * WATCH = 6; + */ + WATCH(6, 6), + /** + * UNWATCH = 7; + */ + UNWATCH(7, 7), + /** + * FAILED = 8; + */ + FAILED(8, 8), + /** + * DEATHWATCH_NOTIFICATION = 9; + */ + DEATHWATCH_NOTIFICATION(9, 9), + ; + + /** + * CREATE = 0; + */ + public static final int CREATE_VALUE = 0; + /** + * RECREATE = 1; + */ + public static final int RECREATE_VALUE = 1; + /** + * SUSPEND = 2; + */ + public static final int SUSPEND_VALUE = 2; + /** + * RESUME = 3; + */ + public static final int RESUME_VALUE = 3; + /** + * TERMINATE = 4; + */ + public static final int TERMINATE_VALUE = 4; + /** + * SUPERVISE = 5; + */ + public static final int SUPERVISE_VALUE = 5; + /** + * WATCH = 6; + */ + public static final int WATCH_VALUE = 6; + /** + * UNWATCH = 7; + */ + public static final int UNWATCH_VALUE = 7; + /** + * FAILED = 8; + */ + public static final int FAILED_VALUE = 8; + /** + * DEATHWATCH_NOTIFICATION = 9; + */ + public static final int DEATHWATCH_NOTIFICATION_VALUE = 9; + + + public final int getNumber() { return value; } + + public static Type valueOf(int value) { + switch (value) { + case 0: return CREATE; + case 1: return RECREATE; + case 2: return SUSPEND; + case 3: return RESUME; + case 4: return TERMINATE; + case 5: return SUPERVISE; + case 6: return WATCH; + case 7: return UNWATCH; + case 8: return FAILED; + case 9: return DEATHWATCH_NOTIFICATION; + default: return null; + } + } + + public static akka.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static akka.protobuf.Internal.EnumLiteMap + internalValueMap = + new akka.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.valueOf(number); + } + }; + + public final akka.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final akka.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final akka.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.SystemMessage.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + akka.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private Type(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:SystemMessage.Type) + } + + private int bitField0_; + // required .SystemMessage.Type type = 1; + public static final int TYPE_FIELD_NUMBER = 1; + private akka.remote.SystemMessageFormats.SystemMessage.Type type_; + /** + * required .SystemMessage.Type type = 1; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .SystemMessage.Type type = 1; + */ + public akka.remote.SystemMessageFormats.SystemMessage.Type getType() { + return type_; + } + + // optional .WatchData watchData = 2; + public static final int WATCHDATA_FIELD_NUMBER = 2; + private akka.remote.SystemMessageFormats.WatchData watchData_; + /** + * optional .WatchData watchData = 2; + */ + public boolean hasWatchData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .WatchData watchData = 2; + */ + public akka.remote.SystemMessageFormats.WatchData getWatchData() { + return watchData_; + } + /** + * optional .WatchData watchData = 2; + */ + public akka.remote.SystemMessageFormats.WatchDataOrBuilder getWatchDataOrBuilder() { + return watchData_; + } + + // optional .Payload causeData = 3; + public static final int CAUSEDATA_FIELD_NUMBER = 3; + private akka.remote.ContainerFormats.Payload causeData_; + /** + * optional .Payload causeData = 3; + */ + public boolean hasCauseData() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .Payload causeData = 3; + */ + public akka.remote.ContainerFormats.Payload getCauseData() { + return causeData_; + } + /** + * optional .Payload causeData = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseDataOrBuilder() { + return causeData_; + } + + // optional .SuperviseData superviseData = 5; + public static final int SUPERVISEDATA_FIELD_NUMBER = 5; + private akka.remote.SystemMessageFormats.SuperviseData superviseData_; + /** + * optional .SuperviseData superviseData = 5; + */ + public boolean hasSuperviseData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .SuperviseData superviseData = 5; + */ + public akka.remote.SystemMessageFormats.SuperviseData getSuperviseData() { + return superviseData_; + } + /** + * optional .SuperviseData superviseData = 5; + */ + public akka.remote.SystemMessageFormats.SuperviseDataOrBuilder getSuperviseDataOrBuilder() { + return superviseData_; + } + + // optional .FailedData failedData = 6; + public static final int FAILEDDATA_FIELD_NUMBER = 6; + private akka.remote.SystemMessageFormats.FailedData failedData_; + /** + * optional .FailedData failedData = 6; + */ + public boolean hasFailedData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .FailedData failedData = 6; + */ + public akka.remote.SystemMessageFormats.FailedData getFailedData() { + return failedData_; + } + /** + * optional .FailedData failedData = 6; + */ + public akka.remote.SystemMessageFormats.FailedDataOrBuilder getFailedDataOrBuilder() { + return failedData_; + } + + // optional .DeathWatchNotificationData dwNotificationData = 7; + public static final int DWNOTIFICATIONDATA_FIELD_NUMBER = 7; + private akka.remote.SystemMessageFormats.DeathWatchNotificationData dwNotificationData_; + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public boolean hasDwNotificationData() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public akka.remote.SystemMessageFormats.DeathWatchNotificationData getDwNotificationData() { + return dwNotificationData_; + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder getDwNotificationDataOrBuilder() { + return dwNotificationData_; + } + + private void initFields() { + type_ = akka.remote.SystemMessageFormats.SystemMessage.Type.CREATE; + watchData_ = akka.remote.SystemMessageFormats.WatchData.getDefaultInstance(); + causeData_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + superviseData_ = akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance(); + failedData_ = akka.remote.SystemMessageFormats.FailedData.getDefaultInstance(); + dwNotificationData_ = akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasWatchData()) { + if (!getWatchData().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCauseData()) { + if (!getCauseData().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSuperviseData()) { + if (!getSuperviseData().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasFailedData()) { + if (!getFailedData().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDwNotificationData()) { + if (!getDwNotificationData().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, type_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, watchData_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, causeData_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(5, superviseData_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(6, failedData_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeMessage(7, dwNotificationData_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeEnumSize(1, type_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(2, watchData_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(3, causeData_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(5, superviseData_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(6, failedData_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(7, dwNotificationData_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.SystemMessage parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.SystemMessageFormats.SystemMessage prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code SystemMessage} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.SystemMessageFormats.SystemMessageOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_SystemMessage_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_SystemMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.SystemMessage.class, akka.remote.SystemMessageFormats.SystemMessage.Builder.class); + } + + // Construct using akka.remote.SystemMessageFormats.SystemMessage.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getWatchDataFieldBuilder(); + getCauseDataFieldBuilder(); + getSuperviseDataFieldBuilder(); + getFailedDataFieldBuilder(); + getDwNotificationDataFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + type_ = akka.remote.SystemMessageFormats.SystemMessage.Type.CREATE; + bitField0_ = (bitField0_ & ~0x00000001); + if (watchDataBuilder_ == null) { + watchData_ = akka.remote.SystemMessageFormats.WatchData.getDefaultInstance(); + } else { + watchDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (causeDataBuilder_ == null) { + causeData_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + } else { + causeDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (superviseDataBuilder_ == null) { + superviseData_ = akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance(); + } else { + superviseDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (failedDataBuilder_ == null) { + failedData_ = akka.remote.SystemMessageFormats.FailedData.getDefaultInstance(); + } else { + failedDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (dwNotificationDataBuilder_ == null) { + dwNotificationData_ = akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance(); + } else { + dwNotificationDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.SystemMessageFormats.internal_static_SystemMessage_descriptor; + } + + public akka.remote.SystemMessageFormats.SystemMessage getDefaultInstanceForType() { + return akka.remote.SystemMessageFormats.SystemMessage.getDefaultInstance(); + } + + public akka.remote.SystemMessageFormats.SystemMessage build() { + akka.remote.SystemMessageFormats.SystemMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.SystemMessageFormats.SystemMessage buildPartial() { + akka.remote.SystemMessageFormats.SystemMessage result = new akka.remote.SystemMessageFormats.SystemMessage(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + if (watchDataBuilder_ == null) { + result.watchData_ = watchData_; + } else { + result.watchData_ = watchDataBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (causeDataBuilder_ == null) { + result.causeData_ = causeData_; + } else { + result.causeData_ = causeDataBuilder_.build(); + } + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + if (superviseDataBuilder_ == null) { + result.superviseData_ = superviseData_; + } else { + result.superviseData_ = superviseDataBuilder_.build(); + } + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + if (failedDataBuilder_ == null) { + result.failedData_ = failedData_; + } else { + result.failedData_ = failedDataBuilder_.build(); + } + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + if (dwNotificationDataBuilder_ == null) { + result.dwNotificationData_ = dwNotificationData_; + } else { + result.dwNotificationData_ = dwNotificationDataBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.SystemMessageFormats.SystemMessage) { + return mergeFrom((akka.remote.SystemMessageFormats.SystemMessage)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.SystemMessageFormats.SystemMessage other) { + if (other == akka.remote.SystemMessageFormats.SystemMessage.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasWatchData()) { + mergeWatchData(other.getWatchData()); + } + if (other.hasCauseData()) { + mergeCauseData(other.getCauseData()); + } + if (other.hasSuperviseData()) { + mergeSuperviseData(other.getSuperviseData()); + } + if (other.hasFailedData()) { + mergeFailedData(other.getFailedData()); + } + if (other.hasDwNotificationData()) { + mergeDwNotificationData(other.getDwNotificationData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasType()) { + + return false; + } + if (hasWatchData()) { + if (!getWatchData().isInitialized()) { + + return false; + } + } + if (hasCauseData()) { + if (!getCauseData().isInitialized()) { + + return false; + } + } + if (hasSuperviseData()) { + if (!getSuperviseData().isInitialized()) { + + return false; + } + } + if (hasFailedData()) { + if (!getFailedData().isInitialized()) { + + return false; + } + } + if (hasDwNotificationData()) { + if (!getDwNotificationData().isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.SystemMessageFormats.SystemMessage parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.SystemMessageFormats.SystemMessage) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .SystemMessage.Type type = 1; + private akka.remote.SystemMessageFormats.SystemMessage.Type type_ = akka.remote.SystemMessageFormats.SystemMessage.Type.CREATE; + /** + * required .SystemMessage.Type type = 1; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .SystemMessage.Type type = 1; + */ + public akka.remote.SystemMessageFormats.SystemMessage.Type getType() { + return type_; + } + /** + * required .SystemMessage.Type type = 1; + */ + public Builder setType(akka.remote.SystemMessageFormats.SystemMessage.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value; + onChanged(); + return this; + } + /** + * required .SystemMessage.Type type = 1; + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = akka.remote.SystemMessageFormats.SystemMessage.Type.CREATE; + onChanged(); + return this; + } + + // optional .WatchData watchData = 2; + private akka.remote.SystemMessageFormats.WatchData watchData_ = akka.remote.SystemMessageFormats.WatchData.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.WatchData, akka.remote.SystemMessageFormats.WatchData.Builder, akka.remote.SystemMessageFormats.WatchDataOrBuilder> watchDataBuilder_; + /** + * optional .WatchData watchData = 2; + */ + public boolean hasWatchData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .WatchData watchData = 2; + */ + public akka.remote.SystemMessageFormats.WatchData getWatchData() { + if (watchDataBuilder_ == null) { + return watchData_; + } else { + return watchDataBuilder_.getMessage(); + } + } + /** + * optional .WatchData watchData = 2; + */ + public Builder setWatchData(akka.remote.SystemMessageFormats.WatchData value) { + if (watchDataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + watchData_ = value; + onChanged(); + } else { + watchDataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .WatchData watchData = 2; + */ + public Builder setWatchData( + akka.remote.SystemMessageFormats.WatchData.Builder builderForValue) { + if (watchDataBuilder_ == null) { + watchData_ = builderForValue.build(); + onChanged(); + } else { + watchDataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .WatchData watchData = 2; + */ + public Builder mergeWatchData(akka.remote.SystemMessageFormats.WatchData value) { + if (watchDataBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + watchData_ != akka.remote.SystemMessageFormats.WatchData.getDefaultInstance()) { + watchData_ = + akka.remote.SystemMessageFormats.WatchData.newBuilder(watchData_).mergeFrom(value).buildPartial(); + } else { + watchData_ = value; + } + onChanged(); + } else { + watchDataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .WatchData watchData = 2; + */ + public Builder clearWatchData() { + if (watchDataBuilder_ == null) { + watchData_ = akka.remote.SystemMessageFormats.WatchData.getDefaultInstance(); + onChanged(); + } else { + watchDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .WatchData watchData = 2; + */ + public akka.remote.SystemMessageFormats.WatchData.Builder getWatchDataBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getWatchDataFieldBuilder().getBuilder(); + } + /** + * optional .WatchData watchData = 2; + */ + public akka.remote.SystemMessageFormats.WatchDataOrBuilder getWatchDataOrBuilder() { + if (watchDataBuilder_ != null) { + return watchDataBuilder_.getMessageOrBuilder(); + } else { + return watchData_; + } + } + /** + * optional .WatchData watchData = 2; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.WatchData, akka.remote.SystemMessageFormats.WatchData.Builder, akka.remote.SystemMessageFormats.WatchDataOrBuilder> + getWatchDataFieldBuilder() { + if (watchDataBuilder_ == null) { + watchDataBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.WatchData, akka.remote.SystemMessageFormats.WatchData.Builder, akka.remote.SystemMessageFormats.WatchDataOrBuilder>( + watchData_, + getParentForChildren(), + isClean()); + watchData_ = null; + } + return watchDataBuilder_; + } + + // optional .Payload causeData = 3; + private akka.remote.ContainerFormats.Payload causeData_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> causeDataBuilder_; + /** + * optional .Payload causeData = 3; + */ + public boolean hasCauseData() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .Payload causeData = 3; + */ + public akka.remote.ContainerFormats.Payload getCauseData() { + if (causeDataBuilder_ == null) { + return causeData_; + } else { + return causeDataBuilder_.getMessage(); + } + } + /** + * optional .Payload causeData = 3; + */ + public Builder setCauseData(akka.remote.ContainerFormats.Payload value) { + if (causeDataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + causeData_ = value; + onChanged(); + } else { + causeDataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload causeData = 3; + */ + public Builder setCauseData( + akka.remote.ContainerFormats.Payload.Builder builderForValue) { + if (causeDataBuilder_ == null) { + causeData_ = builderForValue.build(); + onChanged(); + } else { + causeDataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload causeData = 3; + */ + public Builder mergeCauseData(akka.remote.ContainerFormats.Payload value) { + if (causeDataBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + causeData_ != akka.remote.ContainerFormats.Payload.getDefaultInstance()) { + causeData_ = + akka.remote.ContainerFormats.Payload.newBuilder(causeData_).mergeFrom(value).buildPartial(); + } else { + causeData_ = value; + } + onChanged(); + } else { + causeDataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload causeData = 3; + */ + public Builder clearCauseData() { + if (causeDataBuilder_ == null) { + causeData_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + onChanged(); + } else { + causeDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .Payload causeData = 3; + */ + public akka.remote.ContainerFormats.Payload.Builder getCauseDataBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCauseDataFieldBuilder().getBuilder(); + } + /** + * optional .Payload causeData = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseDataOrBuilder() { + if (causeDataBuilder_ != null) { + return causeDataBuilder_.getMessageOrBuilder(); + } else { + return causeData_; + } + } + /** + * optional .Payload causeData = 3; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> + getCauseDataFieldBuilder() { + if (causeDataBuilder_ == null) { + causeDataBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder>( + causeData_, + getParentForChildren(), + isClean()); + causeData_ = null; + } + return causeDataBuilder_; + } + + // optional .SuperviseData superviseData = 5; + private akka.remote.SystemMessageFormats.SuperviseData superviseData_ = akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.SuperviseData, akka.remote.SystemMessageFormats.SuperviseData.Builder, akka.remote.SystemMessageFormats.SuperviseDataOrBuilder> superviseDataBuilder_; + /** + * optional .SuperviseData superviseData = 5; + */ + public boolean hasSuperviseData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .SuperviseData superviseData = 5; + */ + public akka.remote.SystemMessageFormats.SuperviseData getSuperviseData() { + if (superviseDataBuilder_ == null) { + return superviseData_; + } else { + return superviseDataBuilder_.getMessage(); + } + } + /** + * optional .SuperviseData superviseData = 5; + */ + public Builder setSuperviseData(akka.remote.SystemMessageFormats.SuperviseData value) { + if (superviseDataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + superviseData_ = value; + onChanged(); + } else { + superviseDataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .SuperviseData superviseData = 5; + */ + public Builder setSuperviseData( + akka.remote.SystemMessageFormats.SuperviseData.Builder builderForValue) { + if (superviseDataBuilder_ == null) { + superviseData_ = builderForValue.build(); + onChanged(); + } else { + superviseDataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .SuperviseData superviseData = 5; + */ + public Builder mergeSuperviseData(akka.remote.SystemMessageFormats.SuperviseData value) { + if (superviseDataBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + superviseData_ != akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance()) { + superviseData_ = + akka.remote.SystemMessageFormats.SuperviseData.newBuilder(superviseData_).mergeFrom(value).buildPartial(); + } else { + superviseData_ = value; + } + onChanged(); + } else { + superviseDataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .SuperviseData superviseData = 5; + */ + public Builder clearSuperviseData() { + if (superviseDataBuilder_ == null) { + superviseData_ = akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance(); + onChanged(); + } else { + superviseDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .SuperviseData superviseData = 5; + */ + public akka.remote.SystemMessageFormats.SuperviseData.Builder getSuperviseDataBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getSuperviseDataFieldBuilder().getBuilder(); + } + /** + * optional .SuperviseData superviseData = 5; + */ + public akka.remote.SystemMessageFormats.SuperviseDataOrBuilder getSuperviseDataOrBuilder() { + if (superviseDataBuilder_ != null) { + return superviseDataBuilder_.getMessageOrBuilder(); + } else { + return superviseData_; + } + } + /** + * optional .SuperviseData superviseData = 5; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.SuperviseData, akka.remote.SystemMessageFormats.SuperviseData.Builder, akka.remote.SystemMessageFormats.SuperviseDataOrBuilder> + getSuperviseDataFieldBuilder() { + if (superviseDataBuilder_ == null) { + superviseDataBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.SuperviseData, akka.remote.SystemMessageFormats.SuperviseData.Builder, akka.remote.SystemMessageFormats.SuperviseDataOrBuilder>( + superviseData_, + getParentForChildren(), + isClean()); + superviseData_ = null; + } + return superviseDataBuilder_; + } + + // optional .FailedData failedData = 6; + private akka.remote.SystemMessageFormats.FailedData failedData_ = akka.remote.SystemMessageFormats.FailedData.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.FailedData, akka.remote.SystemMessageFormats.FailedData.Builder, akka.remote.SystemMessageFormats.FailedDataOrBuilder> failedDataBuilder_; + /** + * optional .FailedData failedData = 6; + */ + public boolean hasFailedData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .FailedData failedData = 6; + */ + public akka.remote.SystemMessageFormats.FailedData getFailedData() { + if (failedDataBuilder_ == null) { + return failedData_; + } else { + return failedDataBuilder_.getMessage(); + } + } + /** + * optional .FailedData failedData = 6; + */ + public Builder setFailedData(akka.remote.SystemMessageFormats.FailedData value) { + if (failedDataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + failedData_ = value; + onChanged(); + } else { + failedDataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .FailedData failedData = 6; + */ + public Builder setFailedData( + akka.remote.SystemMessageFormats.FailedData.Builder builderForValue) { + if (failedDataBuilder_ == null) { + failedData_ = builderForValue.build(); + onChanged(); + } else { + failedDataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .FailedData failedData = 6; + */ + public Builder mergeFailedData(akka.remote.SystemMessageFormats.FailedData value) { + if (failedDataBuilder_ == null) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + failedData_ != akka.remote.SystemMessageFormats.FailedData.getDefaultInstance()) { + failedData_ = + akka.remote.SystemMessageFormats.FailedData.newBuilder(failedData_).mergeFrom(value).buildPartial(); + } else { + failedData_ = value; + } + onChanged(); + } else { + failedDataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .FailedData failedData = 6; + */ + public Builder clearFailedData() { + if (failedDataBuilder_ == null) { + failedData_ = akka.remote.SystemMessageFormats.FailedData.getDefaultInstance(); + onChanged(); + } else { + failedDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + /** + * optional .FailedData failedData = 6; + */ + public akka.remote.SystemMessageFormats.FailedData.Builder getFailedDataBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getFailedDataFieldBuilder().getBuilder(); + } + /** + * optional .FailedData failedData = 6; + */ + public akka.remote.SystemMessageFormats.FailedDataOrBuilder getFailedDataOrBuilder() { + if (failedDataBuilder_ != null) { + return failedDataBuilder_.getMessageOrBuilder(); + } else { + return failedData_; + } + } + /** + * optional .FailedData failedData = 6; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.FailedData, akka.remote.SystemMessageFormats.FailedData.Builder, akka.remote.SystemMessageFormats.FailedDataOrBuilder> + getFailedDataFieldBuilder() { + if (failedDataBuilder_ == null) { + failedDataBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.FailedData, akka.remote.SystemMessageFormats.FailedData.Builder, akka.remote.SystemMessageFormats.FailedDataOrBuilder>( + failedData_, + getParentForChildren(), + isClean()); + failedData_ = null; + } + return failedDataBuilder_; + } + + // optional .DeathWatchNotificationData dwNotificationData = 7; + private akka.remote.SystemMessageFormats.DeathWatchNotificationData dwNotificationData_ = akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.DeathWatchNotificationData, akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder, akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder> dwNotificationDataBuilder_; + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public boolean hasDwNotificationData() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public akka.remote.SystemMessageFormats.DeathWatchNotificationData getDwNotificationData() { + if (dwNotificationDataBuilder_ == null) { + return dwNotificationData_; + } else { + return dwNotificationDataBuilder_.getMessage(); + } + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public Builder setDwNotificationData(akka.remote.SystemMessageFormats.DeathWatchNotificationData value) { + if (dwNotificationDataBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + dwNotificationData_ = value; + onChanged(); + } else { + dwNotificationDataBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public Builder setDwNotificationData( + akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder builderForValue) { + if (dwNotificationDataBuilder_ == null) { + dwNotificationData_ = builderForValue.build(); + onChanged(); + } else { + dwNotificationDataBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public Builder mergeDwNotificationData(akka.remote.SystemMessageFormats.DeathWatchNotificationData value) { + if (dwNotificationDataBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + dwNotificationData_ != akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance()) { + dwNotificationData_ = + akka.remote.SystemMessageFormats.DeathWatchNotificationData.newBuilder(dwNotificationData_).mergeFrom(value).buildPartial(); + } else { + dwNotificationData_ = value; + } + onChanged(); + } else { + dwNotificationDataBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public Builder clearDwNotificationData() { + if (dwNotificationDataBuilder_ == null) { + dwNotificationData_ = akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance(); + onChanged(); + } else { + dwNotificationDataBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder getDwNotificationDataBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getDwNotificationDataFieldBuilder().getBuilder(); + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + public akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder getDwNotificationDataOrBuilder() { + if (dwNotificationDataBuilder_ != null) { + return dwNotificationDataBuilder_.getMessageOrBuilder(); + } else { + return dwNotificationData_; + } + } + /** + * optional .DeathWatchNotificationData dwNotificationData = 7; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.DeathWatchNotificationData, akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder, akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder> + getDwNotificationDataFieldBuilder() { + if (dwNotificationDataBuilder_ == null) { + dwNotificationDataBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.SystemMessageFormats.DeathWatchNotificationData, akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder, akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder>( + dwNotificationData_, + getParentForChildren(), + isClean()); + dwNotificationData_ = null; + } + return dwNotificationDataBuilder_; + } + + // @@protoc_insertion_point(builder_scope:SystemMessage) + } + + static { + defaultInstance = new SystemMessage(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:SystemMessage) + } + + public interface WatchDataOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required .ActorRef watchee = 1; + /** + * required .ActorRef watchee = 1; + */ + boolean hasWatchee(); + /** + * required .ActorRef watchee = 1; + */ + akka.remote.ContainerFormats.ActorRef getWatchee(); + /** + * required .ActorRef watchee = 1; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getWatcheeOrBuilder(); + + // required .ActorRef watcher = 2; + /** + * required .ActorRef watcher = 2; + */ + boolean hasWatcher(); + /** + * required .ActorRef watcher = 2; + */ + akka.remote.ContainerFormats.ActorRef getWatcher(); + /** + * required .ActorRef watcher = 2; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getWatcherOrBuilder(); + } + /** + * Protobuf type {@code WatchData} + */ + public static final class WatchData extends + akka.protobuf.GeneratedMessage + implements WatchDataOrBuilder { + // Use WatchData.newBuilder() to construct. + private WatchData(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private WatchData(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final WatchData defaultInstance; + public static WatchData getDefaultInstance() { + return defaultInstance; + } + + public WatchData getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private WatchData( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = watchee_.toBuilder(); + } + watchee_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(watchee_); + watchee_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = watcher_.toBuilder(); + } + watcher_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(watcher_); + watcher_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_WatchData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_WatchData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.WatchData.class, akka.remote.SystemMessageFormats.WatchData.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public WatchData parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new WatchData(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ActorRef watchee = 1; + public static final int WATCHEE_FIELD_NUMBER = 1; + private akka.remote.ContainerFormats.ActorRef watchee_; + /** + * required .ActorRef watchee = 1; + */ + public boolean hasWatchee() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef watchee = 1; + */ + public akka.remote.ContainerFormats.ActorRef getWatchee() { + return watchee_; + } + /** + * required .ActorRef watchee = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getWatcheeOrBuilder() { + return watchee_; + } + + // required .ActorRef watcher = 2; + public static final int WATCHER_FIELD_NUMBER = 2; + private akka.remote.ContainerFormats.ActorRef watcher_; + /** + * required .ActorRef watcher = 2; + */ + public boolean hasWatcher() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .ActorRef watcher = 2; + */ + public akka.remote.ContainerFormats.ActorRef getWatcher() { + return watcher_; + } + /** + * required .ActorRef watcher = 2; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getWatcherOrBuilder() { + return watcher_; + } + + private void initFields() { + watchee_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + watcher_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasWatchee()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasWatcher()) { + memoizedIsInitialized = 0; + return false; + } + if (!getWatchee().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getWatcher().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, watchee_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, watcher_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(1, watchee_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(2, watcher_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.WatchData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.SystemMessageFormats.WatchData parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.WatchData parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.SystemMessageFormats.WatchData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code WatchData} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.SystemMessageFormats.WatchDataOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_WatchData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_WatchData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.WatchData.class, akka.remote.SystemMessageFormats.WatchData.Builder.class); + } + + // Construct using akka.remote.SystemMessageFormats.WatchData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getWatcheeFieldBuilder(); + getWatcherFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (watcheeBuilder_ == null) { + watchee_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + watcheeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + if (watcherBuilder_ == null) { + watcher_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + watcherBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.SystemMessageFormats.internal_static_WatchData_descriptor; + } + + public akka.remote.SystemMessageFormats.WatchData getDefaultInstanceForType() { + return akka.remote.SystemMessageFormats.WatchData.getDefaultInstance(); + } + + public akka.remote.SystemMessageFormats.WatchData build() { + akka.remote.SystemMessageFormats.WatchData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.SystemMessageFormats.WatchData buildPartial() { + akka.remote.SystemMessageFormats.WatchData result = new akka.remote.SystemMessageFormats.WatchData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (watcheeBuilder_ == null) { + result.watchee_ = watchee_; + } else { + result.watchee_ = watcheeBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + if (watcherBuilder_ == null) { + result.watcher_ = watcher_; + } else { + result.watcher_ = watcherBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.SystemMessageFormats.WatchData) { + return mergeFrom((akka.remote.SystemMessageFormats.WatchData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.SystemMessageFormats.WatchData other) { + if (other == akka.remote.SystemMessageFormats.WatchData.getDefaultInstance()) return this; + if (other.hasWatchee()) { + mergeWatchee(other.getWatchee()); + } + if (other.hasWatcher()) { + mergeWatcher(other.getWatcher()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasWatchee()) { + + return false; + } + if (!hasWatcher()) { + + return false; + } + if (!getWatchee().isInitialized()) { + + return false; + } + if (!getWatcher().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.SystemMessageFormats.WatchData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.SystemMessageFormats.WatchData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ActorRef watchee = 1; + private akka.remote.ContainerFormats.ActorRef watchee_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> watcheeBuilder_; + /** + * required .ActorRef watchee = 1; + */ + public boolean hasWatchee() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef watchee = 1; + */ + public akka.remote.ContainerFormats.ActorRef getWatchee() { + if (watcheeBuilder_ == null) { + return watchee_; + } else { + return watcheeBuilder_.getMessage(); + } + } + /** + * required .ActorRef watchee = 1; + */ + public Builder setWatchee(akka.remote.ContainerFormats.ActorRef value) { + if (watcheeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + watchee_ = value; + onChanged(); + } else { + watcheeBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef watchee = 1; + */ + public Builder setWatchee( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (watcheeBuilder_ == null) { + watchee_ = builderForValue.build(); + onChanged(); + } else { + watcheeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef watchee = 1; + */ + public Builder mergeWatchee(akka.remote.ContainerFormats.ActorRef value) { + if (watcheeBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + watchee_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + watchee_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(watchee_).mergeFrom(value).buildPartial(); + } else { + watchee_ = value; + } + onChanged(); + } else { + watcheeBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef watchee = 1; + */ + public Builder clearWatchee() { + if (watcheeBuilder_ == null) { + watchee_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + watcheeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .ActorRef watchee = 1; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getWatcheeBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getWatcheeFieldBuilder().getBuilder(); + } + /** + * required .ActorRef watchee = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getWatcheeOrBuilder() { + if (watcheeBuilder_ != null) { + return watcheeBuilder_.getMessageOrBuilder(); + } else { + return watchee_; + } + } + /** + * required .ActorRef watchee = 1; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getWatcheeFieldBuilder() { + if (watcheeBuilder_ == null) { + watcheeBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + watchee_, + getParentForChildren(), + isClean()); + watchee_ = null; + } + return watcheeBuilder_; + } + + // required .ActorRef watcher = 2; + private akka.remote.ContainerFormats.ActorRef watcher_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> watcherBuilder_; + /** + * required .ActorRef watcher = 2; + */ + public boolean hasWatcher() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .ActorRef watcher = 2; + */ + public akka.remote.ContainerFormats.ActorRef getWatcher() { + if (watcherBuilder_ == null) { + return watcher_; + } else { + return watcherBuilder_.getMessage(); + } + } + /** + * required .ActorRef watcher = 2; + */ + public Builder setWatcher(akka.remote.ContainerFormats.ActorRef value) { + if (watcherBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + watcher_ = value; + onChanged(); + } else { + watcherBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .ActorRef watcher = 2; + */ + public Builder setWatcher( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (watcherBuilder_ == null) { + watcher_ = builderForValue.build(); + onChanged(); + } else { + watcherBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .ActorRef watcher = 2; + */ + public Builder mergeWatcher(akka.remote.ContainerFormats.ActorRef value) { + if (watcherBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + watcher_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + watcher_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(watcher_).mergeFrom(value).buildPartial(); + } else { + watcher_ = value; + } + onChanged(); + } else { + watcherBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .ActorRef watcher = 2; + */ + public Builder clearWatcher() { + if (watcherBuilder_ == null) { + watcher_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + watcherBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * required .ActorRef watcher = 2; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getWatcherBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getWatcherFieldBuilder().getBuilder(); + } + /** + * required .ActorRef watcher = 2; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getWatcherOrBuilder() { + if (watcherBuilder_ != null) { + return watcherBuilder_.getMessageOrBuilder(); + } else { + return watcher_; + } + } + /** + * required .ActorRef watcher = 2; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getWatcherFieldBuilder() { + if (watcherBuilder_ == null) { + watcherBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + watcher_, + getParentForChildren(), + isClean()); + watcher_ = null; + } + return watcherBuilder_; + } + + // @@protoc_insertion_point(builder_scope:WatchData) + } + + static { + defaultInstance = new WatchData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:WatchData) + } + + public interface SuperviseDataOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required .ActorRef child = 1; + /** + * required .ActorRef child = 1; + */ + boolean hasChild(); + /** + * required .ActorRef child = 1; + */ + akka.remote.ContainerFormats.ActorRef getChild(); + /** + * required .ActorRef child = 1; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder(); + + // required bool async = 2; + /** + * required bool async = 2; + */ + boolean hasAsync(); + /** + * required bool async = 2; + */ + boolean getAsync(); + } + /** + * Protobuf type {@code SuperviseData} + */ + public static final class SuperviseData extends + akka.protobuf.GeneratedMessage + implements SuperviseDataOrBuilder { + // Use SuperviseData.newBuilder() to construct. + private SuperviseData(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private SuperviseData(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final SuperviseData defaultInstance; + public static SuperviseData getDefaultInstance() { + return defaultInstance; + } + + public SuperviseData getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private SuperviseData( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = child_.toBuilder(); + } + child_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(child_); + child_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + async_ = input.readBool(); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_SuperviseData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_SuperviseData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.SuperviseData.class, akka.remote.SystemMessageFormats.SuperviseData.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public SuperviseData parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new SuperviseData(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ActorRef child = 1; + public static final int CHILD_FIELD_NUMBER = 1; + private akka.remote.ContainerFormats.ActorRef child_; + /** + * required .ActorRef child = 1; + */ + public boolean hasChild() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef getChild() { + return child_; + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder() { + return child_; + } + + // required bool async = 2; + public static final int ASYNC_FIELD_NUMBER = 2; + private boolean async_; + /** + * required bool async = 2; + */ + public boolean hasAsync() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool async = 2; + */ + public boolean getAsync() { + return async_; + } + + private void initFields() { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + async_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasChild()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAsync()) { + memoizedIsInitialized = 0; + return false; + } + if (!getChild().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, child_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBool(2, async_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(1, child_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeBoolSize(2, async_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.SuperviseData parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.SystemMessageFormats.SuperviseData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code SuperviseData} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.SystemMessageFormats.SuperviseDataOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_SuperviseData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_SuperviseData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.SuperviseData.class, akka.remote.SystemMessageFormats.SuperviseData.Builder.class); + } + + // Construct using akka.remote.SystemMessageFormats.SuperviseData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getChildFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (childBuilder_ == null) { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + childBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + async_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.SystemMessageFormats.internal_static_SuperviseData_descriptor; + } + + public akka.remote.SystemMessageFormats.SuperviseData getDefaultInstanceForType() { + return akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance(); + } + + public akka.remote.SystemMessageFormats.SuperviseData build() { + akka.remote.SystemMessageFormats.SuperviseData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.SystemMessageFormats.SuperviseData buildPartial() { + akka.remote.SystemMessageFormats.SuperviseData result = new akka.remote.SystemMessageFormats.SuperviseData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (childBuilder_ == null) { + result.child_ = child_; + } else { + result.child_ = childBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.async_ = async_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.SystemMessageFormats.SuperviseData) { + return mergeFrom((akka.remote.SystemMessageFormats.SuperviseData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.SystemMessageFormats.SuperviseData other) { + if (other == akka.remote.SystemMessageFormats.SuperviseData.getDefaultInstance()) return this; + if (other.hasChild()) { + mergeChild(other.getChild()); + } + if (other.hasAsync()) { + setAsync(other.getAsync()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasChild()) { + + return false; + } + if (!hasAsync()) { + + return false; + } + if (!getChild().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.SystemMessageFormats.SuperviseData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.SystemMessageFormats.SuperviseData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ActorRef child = 1; + private akka.remote.ContainerFormats.ActorRef child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> childBuilder_; + /** + * required .ActorRef child = 1; + */ + public boolean hasChild() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef getChild() { + if (childBuilder_ == null) { + return child_; + } else { + return childBuilder_.getMessage(); + } + } + /** + * required .ActorRef child = 1; + */ + public Builder setChild(akka.remote.ContainerFormats.ActorRef value) { + if (childBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + child_ = value; + onChanged(); + } else { + childBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder setChild( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (childBuilder_ == null) { + child_ = builderForValue.build(); + onChanged(); + } else { + childBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder mergeChild(akka.remote.ContainerFormats.ActorRef value) { + if (childBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + child_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + child_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(child_).mergeFrom(value).buildPartial(); + } else { + child_ = value; + } + onChanged(); + } else { + childBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder clearChild() { + if (childBuilder_ == null) { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + childBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getChildBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getChildFieldBuilder().getBuilder(); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder() { + if (childBuilder_ != null) { + return childBuilder_.getMessageOrBuilder(); + } else { + return child_; + } + } + /** + * required .ActorRef child = 1; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getChildFieldBuilder() { + if (childBuilder_ == null) { + childBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + child_, + getParentForChildren(), + isClean()); + child_ = null; + } + return childBuilder_; + } + + // required bool async = 2; + private boolean async_ ; + /** + * required bool async = 2; + */ + public boolean hasAsync() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool async = 2; + */ + public boolean getAsync() { + return async_; + } + /** + * required bool async = 2; + */ + public Builder setAsync(boolean value) { + bitField0_ |= 0x00000002; + async_ = value; + onChanged(); + return this; + } + /** + * required bool async = 2; + */ + public Builder clearAsync() { + bitField0_ = (bitField0_ & ~0x00000002); + async_ = false; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:SuperviseData) + } + + static { + defaultInstance = new SuperviseData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:SuperviseData) + } + + public interface FailedDataOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required .ActorRef child = 1; + /** + * required .ActorRef child = 1; + */ + boolean hasChild(); + /** + * required .ActorRef child = 1; + */ + akka.remote.ContainerFormats.ActorRef getChild(); + /** + * required .ActorRef child = 1; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder(); + + // required uint64 uid = 2; + /** + * required uint64 uid = 2; + */ + boolean hasUid(); + /** + * required uint64 uid = 2; + */ + long getUid(); + } + /** + * Protobuf type {@code FailedData} + */ + public static final class FailedData extends + akka.protobuf.GeneratedMessage + implements FailedDataOrBuilder { + // Use FailedData.newBuilder() to construct. + private FailedData(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private FailedData(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final FailedData defaultInstance; + public static FailedData getDefaultInstance() { + return defaultInstance; + } + + public FailedData getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FailedData( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = child_.toBuilder(); + } + child_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(child_); + child_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + uid_ = input.readUInt64(); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_FailedData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_FailedData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.FailedData.class, akka.remote.SystemMessageFormats.FailedData.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public FailedData parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new FailedData(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ActorRef child = 1; + public static final int CHILD_FIELD_NUMBER = 1; + private akka.remote.ContainerFormats.ActorRef child_; + /** + * required .ActorRef child = 1; + */ + public boolean hasChild() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef getChild() { + return child_; + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder() { + return child_; + } + + // required uint64 uid = 2; + public static final int UID_FIELD_NUMBER = 2; + private long uid_; + /** + * required uint64 uid = 2; + */ + public boolean hasUid() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required uint64 uid = 2; + */ + public long getUid() { + return uid_; + } + + private void initFields() { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + uid_ = 0L; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasChild()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasUid()) { + memoizedIsInitialized = 0; + return false; + } + if (!getChild().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, child_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeUInt64(2, uid_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(1, child_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeUInt64Size(2, uid_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.FailedData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.SystemMessageFormats.FailedData parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.FailedData parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.SystemMessageFormats.FailedData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code FailedData} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.SystemMessageFormats.FailedDataOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_FailedData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_FailedData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.FailedData.class, akka.remote.SystemMessageFormats.FailedData.Builder.class); + } + + // Construct using akka.remote.SystemMessageFormats.FailedData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getChildFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (childBuilder_ == null) { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + childBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + uid_ = 0L; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.SystemMessageFormats.internal_static_FailedData_descriptor; + } + + public akka.remote.SystemMessageFormats.FailedData getDefaultInstanceForType() { + return akka.remote.SystemMessageFormats.FailedData.getDefaultInstance(); + } + + public akka.remote.SystemMessageFormats.FailedData build() { + akka.remote.SystemMessageFormats.FailedData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.SystemMessageFormats.FailedData buildPartial() { + akka.remote.SystemMessageFormats.FailedData result = new akka.remote.SystemMessageFormats.FailedData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (childBuilder_ == null) { + result.child_ = child_; + } else { + result.child_ = childBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.uid_ = uid_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.SystemMessageFormats.FailedData) { + return mergeFrom((akka.remote.SystemMessageFormats.FailedData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.SystemMessageFormats.FailedData other) { + if (other == akka.remote.SystemMessageFormats.FailedData.getDefaultInstance()) return this; + if (other.hasChild()) { + mergeChild(other.getChild()); + } + if (other.hasUid()) { + setUid(other.getUid()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasChild()) { + + return false; + } + if (!hasUid()) { + + return false; + } + if (!getChild().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.SystemMessageFormats.FailedData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.SystemMessageFormats.FailedData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ActorRef child = 1; + private akka.remote.ContainerFormats.ActorRef child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> childBuilder_; + /** + * required .ActorRef child = 1; + */ + public boolean hasChild() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef getChild() { + if (childBuilder_ == null) { + return child_; + } else { + return childBuilder_.getMessage(); + } + } + /** + * required .ActorRef child = 1; + */ + public Builder setChild(akka.remote.ContainerFormats.ActorRef value) { + if (childBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + child_ = value; + onChanged(); + } else { + childBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder setChild( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (childBuilder_ == null) { + child_ = builderForValue.build(); + onChanged(); + } else { + childBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder mergeChild(akka.remote.ContainerFormats.ActorRef value) { + if (childBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + child_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + child_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(child_).mergeFrom(value).buildPartial(); + } else { + child_ = value; + } + onChanged(); + } else { + childBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef child = 1; + */ + public Builder clearChild() { + if (childBuilder_ == null) { + child_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + childBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getChildBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getChildFieldBuilder().getBuilder(); + } + /** + * required .ActorRef child = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getChildOrBuilder() { + if (childBuilder_ != null) { + return childBuilder_.getMessageOrBuilder(); + } else { + return child_; + } + } + /** + * required .ActorRef child = 1; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getChildFieldBuilder() { + if (childBuilder_ == null) { + childBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + child_, + getParentForChildren(), + isClean()); + child_ = null; + } + return childBuilder_; + } + + // required uint64 uid = 2; + private long uid_ ; + /** + * required uint64 uid = 2; + */ + public boolean hasUid() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required uint64 uid = 2; + */ + public long getUid() { + return uid_; + } + /** + * required uint64 uid = 2; + */ + public Builder setUid(long value) { + bitField0_ |= 0x00000002; + uid_ = value; + onChanged(); + return this; + } + /** + * required uint64 uid = 2; + */ + public Builder clearUid() { + bitField0_ = (bitField0_ & ~0x00000002); + uid_ = 0L; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:FailedData) + } + + static { + defaultInstance = new FailedData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:FailedData) + } + + public interface DeathWatchNotificationDataOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required .ActorRef actor = 1; + /** + * required .ActorRef actor = 1; + */ + boolean hasActor(); + /** + * required .ActorRef actor = 1; + */ + akka.remote.ContainerFormats.ActorRef getActor(); + /** + * required .ActorRef actor = 1; + */ + akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder(); + + // required bool existenceConfirmed = 2; + /** + * required bool existenceConfirmed = 2; + */ + boolean hasExistenceConfirmed(); + /** + * required bool existenceConfirmed = 2; + */ + boolean getExistenceConfirmed(); + + // required bool addressTerminated = 3; + /** + * required bool addressTerminated = 3; + */ + boolean hasAddressTerminated(); + /** + * required bool addressTerminated = 3; + */ + boolean getAddressTerminated(); + } + /** + * Protobuf type {@code DeathWatchNotificationData} + */ + public static final class DeathWatchNotificationData extends + akka.protobuf.GeneratedMessage + implements DeathWatchNotificationDataOrBuilder { + // Use DeathWatchNotificationData.newBuilder() to construct. + private DeathWatchNotificationData(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private DeathWatchNotificationData(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final DeathWatchNotificationData defaultInstance; + public static DeathWatchNotificationData getDefaultInstance() { + return defaultInstance; + } + + public DeathWatchNotificationData getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DeathWatchNotificationData( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + akka.remote.ContainerFormats.ActorRef.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = actor_.toBuilder(); + } + actor_ = input.readMessage(akka.remote.ContainerFormats.ActorRef.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(actor_); + actor_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + existenceConfirmed_ = input.readBool(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + addressTerminated_ = input.readBool(); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_DeathWatchNotificationData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_DeathWatchNotificationData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.DeathWatchNotificationData.class, akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public DeathWatchNotificationData parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new DeathWatchNotificationData(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ActorRef actor = 1; + public static final int ACTOR_FIELD_NUMBER = 1; + private akka.remote.ContainerFormats.ActorRef actor_; + /** + * required .ActorRef actor = 1; + */ + public boolean hasActor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef getActor() { + return actor_; + } + /** + * required .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder() { + return actor_; + } + + // required bool existenceConfirmed = 2; + public static final int EXISTENCECONFIRMED_FIELD_NUMBER = 2; + private boolean existenceConfirmed_; + /** + * required bool existenceConfirmed = 2; + */ + public boolean hasExistenceConfirmed() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool existenceConfirmed = 2; + */ + public boolean getExistenceConfirmed() { + return existenceConfirmed_; + } + + // required bool addressTerminated = 3; + public static final int ADDRESSTERMINATED_FIELD_NUMBER = 3; + private boolean addressTerminated_; + /** + * required bool addressTerminated = 3; + */ + public boolean hasAddressTerminated() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool addressTerminated = 3; + */ + public boolean getAddressTerminated() { + return addressTerminated_; + } + + private void initFields() { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + existenceConfirmed_ = false; + addressTerminated_ = false; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasActor()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasExistenceConfirmed()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAddressTerminated()) { + memoizedIsInitialized = 0; + return false; + } + if (!getActor().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, actor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBool(2, existenceConfirmed_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBool(3, addressTerminated_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(1, actor_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeBoolSize(2, existenceConfirmed_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += akka.protobuf.CodedOutputStream + .computeBoolSize(3, addressTerminated_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.SystemMessageFormats.DeathWatchNotificationData parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.SystemMessageFormats.DeathWatchNotificationData prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code DeathWatchNotificationData} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.SystemMessageFormats.DeathWatchNotificationDataOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.SystemMessageFormats.internal_static_DeathWatchNotificationData_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.SystemMessageFormats.internal_static_DeathWatchNotificationData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.SystemMessageFormats.DeathWatchNotificationData.class, akka.remote.SystemMessageFormats.DeathWatchNotificationData.Builder.class); + } + + // Construct using akka.remote.SystemMessageFormats.DeathWatchNotificationData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getActorFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (actorBuilder_ == null) { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + } else { + actorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + existenceConfirmed_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + addressTerminated_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.SystemMessageFormats.internal_static_DeathWatchNotificationData_descriptor; + } + + public akka.remote.SystemMessageFormats.DeathWatchNotificationData getDefaultInstanceForType() { + return akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance(); + } + + public akka.remote.SystemMessageFormats.DeathWatchNotificationData build() { + akka.remote.SystemMessageFormats.DeathWatchNotificationData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.SystemMessageFormats.DeathWatchNotificationData buildPartial() { + akka.remote.SystemMessageFormats.DeathWatchNotificationData result = new akka.remote.SystemMessageFormats.DeathWatchNotificationData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (actorBuilder_ == null) { + result.actor_ = actor_; + } else { + result.actor_ = actorBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.existenceConfirmed_ = existenceConfirmed_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.addressTerminated_ = addressTerminated_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.SystemMessageFormats.DeathWatchNotificationData) { + return mergeFrom((akka.remote.SystemMessageFormats.DeathWatchNotificationData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.SystemMessageFormats.DeathWatchNotificationData other) { + if (other == akka.remote.SystemMessageFormats.DeathWatchNotificationData.getDefaultInstance()) return this; + if (other.hasActor()) { + mergeActor(other.getActor()); + } + if (other.hasExistenceConfirmed()) { + setExistenceConfirmed(other.getExistenceConfirmed()); + } + if (other.hasAddressTerminated()) { + setAddressTerminated(other.getAddressTerminated()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasActor()) { + + return false; + } + if (!hasExistenceConfirmed()) { + + return false; + } + if (!hasAddressTerminated()) { + + return false; + } + if (!getActor().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.SystemMessageFormats.DeathWatchNotificationData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.SystemMessageFormats.DeathWatchNotificationData) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ActorRef actor = 1; + private akka.remote.ContainerFormats.ActorRef actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> actorBuilder_; + /** + * required .ActorRef actor = 1; + */ + public boolean hasActor() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef getActor() { + if (actorBuilder_ == null) { + return actor_; + } else { + return actorBuilder_.getMessage(); + } + } + /** + * required .ActorRef actor = 1; + */ + public Builder setActor(akka.remote.ContainerFormats.ActorRef value) { + if (actorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + actor_ = value; + onChanged(); + } else { + actorBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef actor = 1; + */ + public Builder setActor( + akka.remote.ContainerFormats.ActorRef.Builder builderForValue) { + if (actorBuilder_ == null) { + actor_ = builderForValue.build(); + onChanged(); + } else { + actorBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef actor = 1; + */ + public Builder mergeActor(akka.remote.ContainerFormats.ActorRef value) { + if (actorBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + actor_ != akka.remote.ContainerFormats.ActorRef.getDefaultInstance()) { + actor_ = + akka.remote.ContainerFormats.ActorRef.newBuilder(actor_).mergeFrom(value).buildPartial(); + } else { + actor_ = value; + } + onChanged(); + } else { + actorBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .ActorRef actor = 1; + */ + public Builder clearActor() { + if (actorBuilder_ == null) { + actor_ = akka.remote.ContainerFormats.ActorRef.getDefaultInstance(); + onChanged(); + } else { + actorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRef.Builder getActorBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getActorFieldBuilder().getBuilder(); + } + /** + * required .ActorRef actor = 1; + */ + public akka.remote.ContainerFormats.ActorRefOrBuilder getActorOrBuilder() { + if (actorBuilder_ != null) { + return actorBuilder_.getMessageOrBuilder(); + } else { + return actor_; + } + } + /** + * required .ActorRef actor = 1; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder> + getActorFieldBuilder() { + if (actorBuilder_ == null) { + actorBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.ActorRef, akka.remote.ContainerFormats.ActorRef.Builder, akka.remote.ContainerFormats.ActorRefOrBuilder>( + actor_, + getParentForChildren(), + isClean()); + actor_ = null; + } + return actorBuilder_; + } + + // required bool existenceConfirmed = 2; + private boolean existenceConfirmed_ ; + /** + * required bool existenceConfirmed = 2; + */ + public boolean hasExistenceConfirmed() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required bool existenceConfirmed = 2; + */ + public boolean getExistenceConfirmed() { + return existenceConfirmed_; + } + /** + * required bool existenceConfirmed = 2; + */ + public Builder setExistenceConfirmed(boolean value) { + bitField0_ |= 0x00000002; + existenceConfirmed_ = value; + onChanged(); + return this; + } + /** + * required bool existenceConfirmed = 2; + */ + public Builder clearExistenceConfirmed() { + bitField0_ = (bitField0_ & ~0x00000002); + existenceConfirmed_ = false; + onChanged(); + return this; + } + + // required bool addressTerminated = 3; + private boolean addressTerminated_ ; + /** + * required bool addressTerminated = 3; + */ + public boolean hasAddressTerminated() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required bool addressTerminated = 3; + */ + public boolean getAddressTerminated() { + return addressTerminated_; + } + /** + * required bool addressTerminated = 3; + */ + public Builder setAddressTerminated(boolean value) { + bitField0_ |= 0x00000004; + addressTerminated_ = value; + onChanged(); + return this; + } + /** + * required bool addressTerminated = 3; + */ + public Builder clearAddressTerminated() { + bitField0_ = (bitField0_ & ~0x00000004); + addressTerminated_ = false; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:DeathWatchNotificationData) + } + + static { + defaultInstance = new DeathWatchNotificationData(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:DeathWatchNotificationData) + } + + private static akka.protobuf.Descriptors.Descriptor + internal_static_SystemMessage_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_SystemMessage_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_WatchData_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_WatchData_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_SuperviseData_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_SuperviseData_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_FailedData_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_FailedData_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_DeathWatchNotificationData_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_DeathWatchNotificationData_fieldAccessorTable; + + public static akka.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static akka.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\032SystemMessageFormats.proto\032\026ContainerF" + + "ormats.proto\"\212\003\n\rSystemMessage\022!\n\004type\030\001" + + " \002(\0162\023.SystemMessage.Type\022\035\n\twatchData\030\002" + + " \001(\0132\n.WatchData\022\033\n\tcauseData\030\003 \001(\0132\010.Pa" + + "yload\022%\n\rsuperviseData\030\005 \001(\0132\016.Supervise" + + "Data\022\037\n\nfailedData\030\006 \001(\0132\013.FailedData\0227\n" + + "\022dwNotificationData\030\007 \001(\0132\033.DeathWatchNo" + + "tificationData\"\230\001\n\004Type\022\n\n\006CREATE\020\000\022\014\n\010R" + + "ECREATE\020\001\022\013\n\007SUSPEND\020\002\022\n\n\006RESUME\020\003\022\r\n\tTE" + + "RMINATE\020\004\022\r\n\tSUPERVISE\020\005\022\t\n\005WATCH\020\006\022\013\n\007U", + "NWATCH\020\007\022\n\n\006FAILED\020\010\022\033\n\027DEATHWATCH_NOTIF" + + "ICATION\020\t\"C\n\tWatchData\022\032\n\007watchee\030\001 \002(\0132" + + "\t.ActorRef\022\032\n\007watcher\030\002 \002(\0132\t.ActorRef\"8" + + "\n\rSuperviseData\022\030\n\005child\030\001 \002(\0132\t.ActorRe" + + "f\022\r\n\005async\030\002 \002(\010\"3\n\nFailedData\022\030\n\005child\030" + + "\001 \002(\0132\t.ActorRef\022\013\n\003uid\030\002 \002(\004\"m\n\032DeathWa" + + "tchNotificationData\022\030\n\005actor\030\001 \002(\0132\t.Act" + + "orRef\022\032\n\022existenceConfirmed\030\002 \002(\010\022\031\n\021add" + + "ressTerminated\030\003 \002(\010B\017\n\013akka.remoteH\001" + }; + akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public akka.protobuf.ExtensionRegistry assignDescriptors( + akka.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + internal_static_SystemMessage_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_SystemMessage_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_SystemMessage_descriptor, + new java.lang.String[] { "Type", "WatchData", "CauseData", "SuperviseData", "FailedData", "DwNotificationData", }); + internal_static_WatchData_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_WatchData_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_WatchData_descriptor, + new java.lang.String[] { "Watchee", "Watcher", }); + internal_static_SuperviseData_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_SuperviseData_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_SuperviseData_descriptor, + new java.lang.String[] { "Child", "Async", }); + internal_static_FailedData_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_FailedData_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_FailedData_descriptor, + new java.lang.String[] { "Child", "Uid", }); + internal_static_DeathWatchNotificationData_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_DeathWatchNotificationData_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_DeathWatchNotificationData_descriptor, + new java.lang.String[] { "Actor", "ExistenceConfirmed", "AddressTerminated", }); + return null; + } + }; + akka.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new akka.protobuf.Descriptors.FileDescriptor[] { + akka.remote.ContainerFormats.getDescriptor(), + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/akka-remote/src/main/protobuf/ContainerFormats.proto b/akka-remote/src/main/protobuf/ContainerFormats.proto index 6ff9fda613..a760413f8d 100644 --- a/akka-remote/src/main/protobuf/ContainerFormats.proto +++ b/akka-remote/src/main/protobuf/ContainerFormats.proto @@ -51,6 +51,10 @@ message Payload { optional bytes messageManifest = 4; } +message WatcherHeartbeatResponse { + required uint64 uid = 1; +} + message Throwable { required string className = 1; optional string message = 2; @@ -58,6 +62,12 @@ message Throwable { repeated StackTraceElement stackTrace = 4; } +message ActorInitializationException { + optional ActorRef actor = 1; + required string message = 2; + required Payload cause = 3; +} + message StackTraceElement { required string className = 1; required string methodName = 2; diff --git a/akka-remote/src/main/protobuf/SystemMessageFormats.proto b/akka-remote/src/main/protobuf/SystemMessageFormats.proto new file mode 100644 index 0000000000..1c6a0d51fa --- /dev/null +++ b/akka-remote/src/main/protobuf/SystemMessageFormats.proto @@ -0,0 +1,62 @@ +/** + * Copyright (C) 2009-2015 Lightbend Inc. + */ + +option java_package = "akka.remote"; +option optimize_for = SPEED; + +import "ContainerFormats.proto"; + +/****************************************** + * System message formats + ******************************************/ + +message SystemMessage { + enum Type { + CREATE = 0; + RECREATE = 1; + SUSPEND = 2; + RESUME = 3; + TERMINATE = 4; + SUPERVISE = 5; + WATCH = 6; + UNWATCH = 7; + FAILED = 8; + DEATHWATCH_NOTIFICATION = 9; + } + + required Type type = 1; + + optional WatchData watchData = 2; + optional Payload causeData = 3; + optional SuperviseData superviseData = 5; + optional FailedData failedData = 6; + optional DeathWatchNotificationData dwNotificationData = 7; + +} + +message WatchData { + required ActorRef watchee = 1; + required ActorRef watcher = 2; +} + +message SuperviseData { + required ActorRef child = 1; + required bool async = 2; +} + +message FailedData { + required ActorRef child = 1; + required uint64 uid = 2; +} + +message DeathWatchNotificationData { + required ActorRef actor = 1; + required bool existenceConfirmed = 2; + required bool addressTerminated = 3; +} + + + + + diff --git a/akka-remote/src/main/resources/reference.conf b/akka-remote/src/main/resources/reference.conf index 3692405d55..390ad12028 100644 --- a/akka-remote/src/main/resources/reference.conf +++ b/akka-remote/src/main/resources/reference.conf @@ -18,6 +18,11 @@ akka { artery = "akka.remote.serialization.ArteryMessageSerializer" proto = "akka.remote.serialization.ProtobufSerializer" daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer" + primitive-long = "akka.remote.serialization.LongSerializer" + primitive-int = "akka.remote.serialization.IntSerializer" + primitive-string = "akka.remote.serialization.StringSerializer" + primitive-bytestring = "akka.remote.serialization.ByteStringSerializer" + akka-system-msg = "akka.remote.serialization.SystemMessageSerializer" } serialization-bindings { @@ -50,7 +55,24 @@ akka { "scala.None$" = akka-misc "akka.actor.Status$Success" = akka-misc "akka.actor.Status$Failure" = akka-misc - + "akka.actor.ActorRef" = akka-misc + "akka.actor.PoisonPill$" = akka-misc + "akka.actor.Kill$" = akka-misc + "akka.remote.RemoteWatcher$Heartbeat$" = akka-misc + "akka.remote.RemoteWatcher$HeartbeatRsp" = akka-misc + "akka.actor.ActorInitializationException" = akka-misc + + "akka.dispatch.sysmsg.SystemMessage" = akka-system-msg + + "java.lang.String" = primitive-string + "akka.util.ByteString$ByteString1C" = primitive-bytestring + "akka.util.ByteString$ByteString1" = primitive-bytestring + "akka.util.ByteString$ByteStrings" = primitive-bytestring + "java.lang.Long" = primitive-long + "scala.Long" = primitive-long + "java.lang.Integer" = primitive-int + "scala.Int" = primitive-int + # Java Serializer is by default used for exceptions. # It's recommended that you implement custom serializer for exceptions that are # sent remotely, e.g. in akka.actor.Status.Failure for ask replies. You can add @@ -58,16 +80,13 @@ akka { # a constructor with single message String or constructor with message String as # first parameter and cause Throwable as second parameter. Note that it's not # safe to add this binding for general exceptions such as IllegalArgumentException - # because it may have a subclass without required constructor. + # because it may have a subclass without required constructor. "java.lang.Throwable" = java "akka.actor.IllegalActorStateException" = akka-misc "akka.actor.ActorKilledException" = akka-misc "akka.actor.InvalidActorNameException" = akka-misc "akka.actor.InvalidMessageException" = akka-misc - - "akka.actor.ActorRef" = akka-misc - - } + } serialization-identifiers { "akka.remote.serialization.ProtobufSerializer" = 2 @@ -75,6 +94,11 @@ akka { "akka.remote.serialization.MessageContainerSerializer" = 6 "akka.remote.serialization.MiscMessageSerializer" = 16 "akka.remote.serialization.ArteryMessageSerializer" = 17 + "akka.remote.serialization.LongSerializer" = 18 + "akka.remote.serialization.IntSerializer" = 19 + "akka.remote.serialization.StringSerializer" = 20 + "akka.remote.serialization.ByteStringSerializer" = 21 + "akka.remote.serialization.SystemMessageSerializer" = 22 } deployment { diff --git a/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala b/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala index 0403515c70..b29c5a2f2d 100644 --- a/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala +++ b/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala @@ -5,30 +5,33 @@ package akka.remote.serialization import akka.actor._ import akka.protobuf.ByteString -import akka.remote.ContainerFormats -import akka.serialization.{ Serialization, BaseSerializer, SerializationExtension, SerializerWithStringManifest } +import akka.remote.{ ContainerFormats, RemoteWatcher } +import akka.serialization.{ BaseSerializer, Serialization, SerializationExtension, SerializerWithStringManifest } class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerWithStringManifest with BaseSerializer { + // WARNING! This must lazy otherwise it will deadlock the ActorSystem creation private lazy val serialization = SerializationExtension(system) private val payloadSupport = new WrappedPayloadSupport(system) private val throwableSupport = new ThrowableSupport(system) - private val ParameterlessSerialized = Array.empty[Byte] + private val ParameterlessSerializedMessage = Array.empty[Byte] def toBinary(obj: AnyRef): Array[Byte] = obj match { - case identify: Identify ⇒ serializeIdentify(identify) - case identity: ActorIdentity ⇒ serializeActorIdentity(identity) - case Some(value) ⇒ serializeSome(value) - case None ⇒ NoneSerialized - case r: ActorRef ⇒ serializeActorRef(r) - case s: Status.Success ⇒ serializeStatusSuccess(s) - case f: Status.Failure ⇒ serializeStatusFailure(f) - case t: Throwable ⇒ throwableSupport.serializeThrowable(t) - case None ⇒ ParameterlessSerialized - case PoisonPill ⇒ ParameterlessSerialized - case Kill ⇒ ParameterlessSerialized - case _ ⇒ throw new IllegalArgumentException(s"Cannot serialize object of type [${obj.getClass.getName}]") + case identify: Identify ⇒ serializeIdentify(identify) + case identity: ActorIdentity ⇒ serializeActorIdentity(identity) + case Some(value) ⇒ serializeSome(value) + case None ⇒ ParameterlessSerializedMessage + case r: ActorRef ⇒ serializeActorRef(r) + case s: Status.Success ⇒ serializeStatusSuccess(s) + case f: Status.Failure ⇒ serializeStatusFailure(f) + case ex: ActorInitializationException ⇒ serializeActorInitializationException(ex) + case t: Throwable ⇒ throwableSupport.serializeThrowable(t) + case PoisonPill ⇒ ParameterlessSerializedMessage + case Kill ⇒ ParameterlessSerializedMessage + case RemoteWatcher.Heartbeat ⇒ ParameterlessSerializedMessage + case hbrsp: RemoteWatcher.HeartbeatRsp ⇒ serializeHeartbeatRsp(hbrsp) + case _ ⇒ throw new IllegalArgumentException(s"Cannot serialize object of type [${obj.getClass.getName}]") } private def serializeIdentify(identify: Identify): Array[Byte] = @@ -60,6 +63,10 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private def serializeActorRef(ref: ActorRef): Array[Byte] = actorRefBuilder(ref).build().toByteArray + private def serializeHeartbeatRsp(hbrsp: RemoteWatcher.HeartbeatRsp): Array[Byte] = { + ContainerFormats.WatcherHeartbeatResponse.newBuilder().setUid(hbrsp.addressUid).build().toByteArray + } + private def actorRefBuilder(actorRef: ActorRef): ContainerFormats.ActorRef.Builder = ContainerFormats.ActorRef.newBuilder() .setPath(Serialization.serializedActorPath(actorRef)) @@ -70,6 +77,17 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private def serializeStatusFailure(failure: Status.Failure): Array[Byte] = payloadSupport.payloadBuilder(failure.cause).build().toByteArray + private def serializeActorInitializationException(ex: ActorInitializationException): Array[Byte] = { + val builder = ContainerFormats.ActorInitializationException.newBuilder() + if (ex.getActor ne null) + builder.setActor(actorRefBuilder(ex.getActor)) + + builder + .setMessage(ex.getMessage) + .setCause(payloadSupport.payloadBuilder(ex.getCause)) + .build().toByteArray + } + private val IdentifyManifest = "A" private val ActorIdentityManifest = "B" private val OptionManifest = "C" @@ -79,34 +97,40 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private val ActorRefManifest = "G" private val PoisonPillManifest = "P" private val KillManifest = "K" + private val RemoteWatcherHBManifest = "RWHB" + private val RemoteWatcherHBRespManifest = "RWHR" + private val ActorInitializationExceptionManifest = "AIEX" private val fromBinaryMap = Map[String, Array[Byte] ⇒ AnyRef]( IdentifyManifest → deserializeIdentify, - ActorIdentifyManifest → deserializeActorIdentity, + ActorIdentityManifest → deserializeActorIdentity, OptionManifest → deserializeOption, StatusSuccessManifest → deserializeStatusSuccess, StatusFailureManifest → deserializeStatusFailure, ThrowableManifest → throwableSupport.deserializeThrowable, - ActorRefManifest → deserializeActorRefBytes) + ActorRefManifest → deserializeActorRefBytes, OptionManifest → deserializeOption, PoisonPillManifest → ((_) ⇒ PoisonPill), - KillManifest → ((_) ⇒ Kill) + KillManifest → ((_) ⇒ Kill), + RemoteWatcherHBManifest → ((_) ⇒ RemoteWatcher.Heartbeat), + RemoteWatcherHBRespManifest → deserializeHeartbeatRsp, + ActorInitializationExceptionManifest → deserializeActorInitializationException ) override def manifest(o: AnyRef): String = o match { - case _: Identify ⇒ IdentifyManifest - case _: ActorIdentity ⇒ ActorIdentifyManifest - case _: Option[Any] ⇒ OptionManifest - case _: ActorRef ⇒ ActorRefManifest - case _: Status.Success ⇒ StatusSuccessManifest - case _: Status.Failure ⇒ StatusFailureManifest - case _: Throwable ⇒ ThrowableManifest - case _: Identify ⇒ IdentifyManifest - case _: ActorIdentity ⇒ ActorIdentityManifest - case _: Option[Any] ⇒ OptionManifest - case _: PoisonPill.type ⇒ PoisonPillManifest - case _: Kill.type ⇒ KillManifest + case _: Identify ⇒ IdentifyManifest + case _: ActorIdentity ⇒ ActorIdentityManifest + case _: Option[Any] ⇒ OptionManifest + case _: ActorRef ⇒ ActorRefManifest + case _: Status.Success ⇒ StatusSuccessManifest + case _: Status.Failure ⇒ StatusFailureManifest + case _: ActorInitializationException ⇒ ActorInitializationExceptionManifest + case _: Throwable ⇒ ThrowableManifest + case PoisonPill ⇒ PoisonPillManifest + case Kill ⇒ KillManifest + case RemoteWatcher.Heartbeat ⇒ RemoteWatcherHBManifest + case _: RemoteWatcher.HeartbeatRsp ⇒ RemoteWatcherHBRespManifest case _ ⇒ throw new IllegalArgumentException(s"Can't serialize object of type ${o.getClass} in [${getClass.getName}]") } @@ -156,4 +180,25 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private def deserializeStatusFailure(bytes: Array[Byte]): Status.Failure = Status.Failure(payloadSupport.deserializePayload(ContainerFormats.Payload.parseFrom(bytes)).asInstanceOf[Throwable]) + private def deserializeHeartbeatRsp(bytes: Array[Byte]): RemoteWatcher.HeartbeatRsp = { + RemoteWatcher.HeartbeatRsp(ContainerFormats.WatcherHeartbeatResponse.parseFrom(bytes).getUid.toInt) + } + + private def deserializeActorInitializationException(bytes: Array[Byte]): ActorInitializationException = { + val serializedEx = ContainerFormats.ActorInitializationException.parseFrom(bytes) + val ref = deserializeActorRef(serializedEx.getActor) + val refString = ref.path.toString + val message = serializedEx.getMessage + + val reconstructedMessage = + if (message.startsWith(refString)) message.drop(refString.length + 2) + else message + + ActorInitializationException( + if (serializedEx.hasActor) ref else null, + reconstructedMessage, + payloadSupport.deserializePayload(serializedEx.getCause).asInstanceOf[Throwable] + ) + } + } diff --git a/akka-remote/src/main/scala/akka/remote/serialization/PrimitiveSerializers.scala b/akka-remote/src/main/scala/akka/remote/serialization/PrimitiveSerializers.scala index 9952652ae4..4b71fd4d12 100644 --- a/akka-remote/src/main/scala/akka/remote/serialization/PrimitiveSerializers.scala +++ b/akka-remote/src/main/scala/akka/remote/serialization/PrimitiveSerializers.scala @@ -1,9 +1,11 @@ package akka.remote.serialization -import java.nio.ByteBuffer +import java.nio.{ BufferOverflowException, ByteBuffer } import akka.actor.{ ExtendedActorSystem, Kill, PoisonPill } +import akka.remote.OversizedPayloadException import akka.serialization.{ BaseSerializer, ByteBufferSerializer } +import akka.util.ByteString class LongSerializer(val system: ExtendedActorSystem) extends BaseSerializer with ByteBufferSerializer { override def includeManifest: Boolean = false @@ -87,3 +89,30 @@ class StringSerializer(val system: ExtendedActorSystem) extends BaseSerializer w override def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]]): AnyRef = new String(bytes, "UTF-8") } + +class ByteStringSerializer(val system: ExtendedActorSystem) extends BaseSerializer with ByteBufferSerializer { + override def includeManifest: Boolean = false + + override def toBinary(o: AnyRef, buf: ByteBuffer): Unit = { + val bs = o.asInstanceOf[ByteString] + + // ByteString.copyToBuffer does not throw BufferOverflowException + if (bs.copyToBuffer(buf) < bs.length) + throw new BufferOverflowException() + } + + override def fromBinary(buf: ByteBuffer, manifest: String): AnyRef = + ByteString.fromByteBuffer(buf) + + override def toBinary(o: AnyRef): Array[Byte] = { + val bs = o.asInstanceOf[ByteString] + val result = Array.ofDim[Byte](bs.length) + bs.copyToArray(result, 0, bs.length) + result + } + + override def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]]): AnyRef = { + ByteString(bytes) + } + +} diff --git a/akka-remote/src/main/scala/akka/remote/serialization/SystemMessageSerializer.scala b/akka-remote/src/main/scala/akka/remote/serialization/SystemMessageSerializer.scala new file mode 100644 index 0000000000..9ba4d423cc --- /dev/null +++ b/akka-remote/src/main/scala/akka/remote/serialization/SystemMessageSerializer.scala @@ -0,0 +1,161 @@ +package akka.remote.serialization + +import akka.actor.{ ActorInitializationException, ActorRef, ExtendedActorSystem, InternalActorRef } +import akka.dispatch.sysmsg._ +import akka.remote.{ ContainerFormats, SystemMessageFormats } +import akka.serialization.{ BaseSerializer, Serialization, SerializationExtension } + +class SystemMessageSerializer(val system: ExtendedActorSystem) extends BaseSerializer { + import SystemMessageFormats.SystemMessage.Type._ + + // WARNING! This must lazy otherwise it will deadlock the ActorSystem creation + private lazy val serialization = SerializationExtension(system) + private val payloadSupport = new WrappedPayloadSupport(system) + + override def includeManifest: Boolean = false + + override def toBinary(o: AnyRef): Array[Byte] = { + val builder = SystemMessageFormats.SystemMessage.newBuilder() + + o.asInstanceOf[SystemMessage] match { + case Create(failure) ⇒ + builder.setType(CREATE) + failure match { + case Some(throwable) ⇒ builder.setCauseData(serializeThrowable(throwable)) + case None ⇒ // Nothing to set + } + + case Recreate(cause) ⇒ + builder.setType(RECREATE) + builder.setCauseData(serializeThrowable(cause)) + + case Suspend() ⇒ + builder.setType(SUSPEND) + + case Resume(cause) ⇒ + builder.setType(RESUME) + builder.setCauseData(serializeThrowable(cause)) + + case Terminate() ⇒ + builder.setType(TERMINATE) + + case Supervise(child, async) ⇒ + builder.setType(SUPERVISE) + val superviseData = SystemMessageFormats.SuperviseData.newBuilder() + .setChild(serializeActorRef(child)) + .setAsync(async) + builder.setSuperviseData(superviseData) + + case Watch(watchee, watcher) ⇒ + builder.setType(WATCH) + val watchData = SystemMessageFormats.WatchData.newBuilder() + .setWatchee(serializeActorRef(watchee)) + .setWatcher(serializeActorRef(watcher)) + builder.setWatchData(watchData) + + case Unwatch(watchee, watcher) ⇒ + builder.setType(UNWATCH) + val watchData = SystemMessageFormats.WatchData.newBuilder() + .setWatchee(serializeActorRef(watchee)) + .setWatcher(serializeActorRef(watcher)) + builder.setWatchData(watchData) + + case Failed(child, cause, uid) ⇒ + builder.setType(FAILED) + val failedData = SystemMessageFormats.FailedData.newBuilder() + .setChild(serializeActorRef(child)) + .setUid(uid) + builder.setCauseData(serializeThrowable(cause)) + builder.setFailedData(failedData) + + case DeathWatchNotification(actor, existenceConfirmed, addressTerminated) ⇒ + builder.setType(DEATHWATCH_NOTIFICATION) + val deathWatchNotificationData = SystemMessageFormats.DeathWatchNotificationData.newBuilder() + .setActor(serializeActorRef(actor)) + .setExistenceConfirmed(existenceConfirmed) + .setAddressTerminated(addressTerminated) + builder.setDwNotificationData(deathWatchNotificationData) + + case NoMessage ⇒ + throw new IllegalArgumentException("NoMessage should never be serialized or deserialized") + } + + builder.build().toByteArray + } + + override def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]]): AnyRef = { + deserializeSystemMessage(SystemMessageFormats.SystemMessage.parseFrom(bytes)) + } + + private def deserializeSystemMessage(sysmsg: SystemMessageFormats.SystemMessage): SystemMessage = + sysmsg.getType match { + case CREATE ⇒ + val cause = + if (sysmsg.hasCauseData) + Some(getCauseThrowable(sysmsg).asInstanceOf[ActorInitializationException]) + else + None + + Create(cause) + + case RECREATE ⇒ + Recreate(getCauseThrowable(sysmsg)) + + case SUSPEND ⇒ + // WARNING!! Must always create a new instance! + Suspend() + + case RESUME ⇒ + Resume(getCauseThrowable(sysmsg)) + + case TERMINATE ⇒ + // WARNING!! Must always create a new instance! + Terminate() + + case SUPERVISE ⇒ + Supervise(deserializeActorRef(sysmsg.getSuperviseData.getChild), sysmsg.getSuperviseData.getAsync) + + case WATCH ⇒ + Watch( + deserializeActorRef(sysmsg.getWatchData.getWatchee).asInstanceOf[InternalActorRef], + deserializeActorRef(sysmsg.getWatchData.getWatcher).asInstanceOf[InternalActorRef] + ) + + case UNWATCH ⇒ + Unwatch( + deserializeActorRef(sysmsg.getWatchData.getWatchee).asInstanceOf[InternalActorRef], + deserializeActorRef(sysmsg.getWatchData.getWatcher).asInstanceOf[InternalActorRef] + ) + + case FAILED ⇒ + Failed( + deserializeActorRef(sysmsg.getFailedData.getChild), + getCauseThrowable(sysmsg), + sysmsg.getFailedData.getUid.toInt) + + case DEATHWATCH_NOTIFICATION ⇒ + DeathWatchNotification( + deserializeActorRef(sysmsg.getDwNotificationData.getActor), + sysmsg.getDwNotificationData.getExistenceConfirmed, + sysmsg.getDwNotificationData.getAddressTerminated + ) + } + + private def serializeThrowable(throwable: Throwable): ContainerFormats.Payload.Builder = { + payloadSupport.payloadBuilder(throwable) + } + + private def getCauseThrowable(msg: SystemMessageFormats.SystemMessage): Throwable = { + payloadSupport.deserializePayload(msg.getCauseData).asInstanceOf[Throwable] + } + + private def serializeActorRef(actorRef: ActorRef): ContainerFormats.ActorRef.Builder = { + ContainerFormats.ActorRef.newBuilder() + .setPath(Serialization.serializedActorPath(actorRef)) + } + + private def deserializeActorRef(serializedRef: ContainerFormats.ActorRef): ActorRef = { + serialization.system.provider.resolveActorRef(serializedRef.getPath) + } + +} diff --git a/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala b/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala index 136f822da2..6d8a276af2 100644 --- a/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala +++ b/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala @@ -16,6 +16,10 @@ private[akka] class ThrowableSupport(system: ExtendedActorSystem) { private val payloadSupport = new WrappedPayloadSupport(system) def serializeThrowable(t: Throwable): Array[Byte] = { + toProtobufThrowable(t).build().toByteArray + } + + def toProtobufThrowable(t: Throwable): ContainerFormats.Throwable.Builder = { val b = ContainerFormats.Throwable.newBuilder() .setClassName(t.getClass.getName) if (t.getMessage != null) @@ -31,7 +35,7 @@ private[akka] class ThrowableSupport(system: ExtendedActorSystem) { } } - b.build().toByteArray + b } def stackTraceElementBuilder(elem: StackTraceElement): ContainerFormats.StackTraceElement.Builder = { @@ -43,7 +47,10 @@ private[akka] class ThrowableSupport(system: ExtendedActorSystem) { } def deserializeThrowable(bytes: Array[Byte]): Throwable = { - val protoT = ContainerFormats.Throwable.parseFrom(bytes) + fromProtobufThrowable(ContainerFormats.Throwable.parseFrom(bytes)) + } + + def fromProtobufThrowable(protoT: ContainerFormats.Throwable): Throwable = { val t: Throwable = if (protoT.hasCause) { val cause = payloadSupport.deserializePayload(protoT.getCause).asInstanceOf[Throwable] @@ -63,9 +70,9 @@ private[akka] class ThrowableSupport(system: ExtendedActorSystem) { import scala.collection.JavaConverters._ val stackTrace = - (protoT.getStackTraceList.asScala.map { elem ⇒ + protoT.getStackTraceList.asScala.map { elem ⇒ new StackTraceElement(elem.getClassName, elem.getMethodName, elem.getFileName, elem.getLineNumber) - }).toArray + }.toArray t.setStackTrace(stackTrace) t } diff --git a/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala b/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala index 32054ddbf6..5e0a2c3b4d 100644 --- a/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala +++ b/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala @@ -5,10 +5,11 @@ package akka.remote.serialization import akka.actor._ -import akka.remote.MessageSerializer +import akka.remote.{ MessageSerializer, RemoteWatcher } import akka.serialization.SerializationExtension import akka.testkit.AkkaSpec import com.typesafe.config.ConfigFactory + import scala.util.control.NoStackTrace object MiscMessageSerializerSpec { @@ -77,7 +78,10 @@ class MiscMessageSerializerSpec extends AkkaSpec(MiscMessageSerializerSpec.testC "Some" → Some("value"), "None" → None, "Kill" → Kill, - "PoisonPill" → PoisonPill).foreach { + "PoisonPill" → PoisonPill, + "RemoteWatcher.Heartbeat" → RemoteWatcher.Heartbeat, + "RemoteWatcher.HertbeatRsp" → RemoteWatcher.HeartbeatRsp(65537) + ).foreach { case (scenario, item) ⇒ s"resolve serializer for $scenario" in { val serializer = SerializationExtension(system) @@ -107,6 +111,45 @@ class MiscMessageSerializerSpec extends AkkaSpec(MiscMessageSerializerSpec.testC val serializer = new MiscMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) serializer.fromBinary(serializer.toBinary(msg), serializer.manifest(msg)) should ===(msg) } + + // Separate tests due to missing equality on ActorInitializationException + "resolve serializer for ActorInitializationException" in { + val serializer = SerializationExtension(system) + serializer.serializerFor(classOf[ActorInitializationException]).getClass should ===(classOf[MiscMessageSerializer]) + } + + "serialize and deserialze ActorInitializationException" in { + val aiex = ActorInitializationException(ref, "test", new TestException("err")) + val serializer = new MiscMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) + val deserialized = serializer.fromBinary(serializer.toBinary(aiex), serializer.manifest(aiex)) + .asInstanceOf[ActorInitializationException] + + deserialized.getCause should ===(aiex.getCause) + deserialized.getMessage should ===(aiex.getMessage) + deserialized.getActor should ===(aiex.getActor) + } + + "serialize and deserialze ActorInitializationException if ref is null" in { + val aiex = ActorInitializationException(null, "test", new TestException("err")) + val serializer = new MiscMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) + val deserialized = serializer.fromBinary(serializer.toBinary(aiex), serializer.manifest(aiex)) + .asInstanceOf[ActorInitializationException] + + deserialized.getCause should ===(aiex.getCause) + deserialized.getMessage should ===(aiex.getMessage) + deserialized.getActor should ===(aiex.getActor) + } + + "serialize and deserialze ActorInitializationException if cause is null" in { + val aiex = ActorInitializationException(ref, "test", null) + val serializer = new MiscMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) + val deserialized = serializer.fromBinary(serializer.toBinary(aiex), serializer.manifest(aiex)) + .asInstanceOf[ActorInitializationException] + + deserialized.getCause should ===(aiex.getCause) + deserialized.getMessage should ===(aiex.getMessage) + deserialized.getActor should ===(aiex.getActor) + } } } diff --git a/akka-remote/src/test/scala/akka/remote/serialization/PrimitivesSerializationSpec.scala b/akka-remote/src/test/scala/akka/remote/serialization/PrimitivesSerializationSpec.scala index 075e839df2..23f5229007 100644 --- a/akka-remote/src/test/scala/akka/remote/serialization/PrimitivesSerializationSpec.scala +++ b/akka-remote/src/test/scala/akka/remote/serialization/PrimitivesSerializationSpec.scala @@ -8,6 +8,7 @@ import java.nio.ByteBuffer import akka.actor.{ ActorIdentity, ExtendedActorSystem, Identify } import akka.serialization.SerializationExtension import akka.testkit.AkkaSpec +import akka.util.ByteString import com.typesafe.config.ConfigFactory import scala.util.Random @@ -126,4 +127,40 @@ class PrimitivesSerializationSpec extends AkkaSpec(PrimitivesSerializationSpec.t } } + "ByteStringSerializer" must { + Seq( + "empty string" → ByteString.empty, + "simple content" → ByteString("hello"), + "concatenated content" → (ByteString("hello") ++ ByteString("world")), + "sliced content" → ByteString("helloabc").take(5) + ).foreach { + case (scenario, item) ⇒ + s"resolve serializer for [$scenario]" in { + val serializer = SerializationExtension(system) + serializer.serializerFor(item.getClass).getClass should ===(classOf[ByteStringSerializer]) + } + + s"serialize and de-serialize [$scenario]" in { + verifySerialization(item) + } + + s"serialize and de-serialize value [$scenario] using ByteBuffers" in { + verifySerializationByteBuffer(item) + } + } + + def verifySerialization(msg: AnyRef): Unit = { + val serializer = new ByteStringSerializer(system.asInstanceOf[ExtendedActorSystem]) + serializer.fromBinary(serializer.toBinary(msg), None) should ===(msg) + } + + def verifySerializationByteBuffer(msg: AnyRef): Unit = { + val serializer = new ByteStringSerializer(system.asInstanceOf[ExtendedActorSystem]) + buffer.clear() + serializer.toBinary(msg, buffer) + buffer.flip() + serializer.fromBinary(buffer, "") should ===(msg) + } + } + } diff --git a/akka-remote/src/test/scala/akka/remote/serialization/SystemMessageSerializationSpec.scala b/akka-remote/src/test/scala/akka/remote/serialization/SystemMessageSerializationSpec.scala new file mode 100644 index 0000000000..ad30a23327 --- /dev/null +++ b/akka-remote/src/test/scala/akka/remote/serialization/SystemMessageSerializationSpec.scala @@ -0,0 +1,79 @@ +package akka.remote.serialization + +import akka.actor.{ ActorInitializationException, ActorRef, ExtendedActorSystem, InternalActorRef } +import akka.dispatch.sysmsg._ +import akka.serialization.SerializationExtension +import akka.testkit.{ AkkaSpec, TestProbe } +import akka.util.ByteString +import com.typesafe.config.ConfigFactory + +object SystemMessageSerializationSpec { + val serializationTestOverrides = + """ + akka.actor.enable-additional-serialization-bindings=on + # or they can be enabled with + # akka.remote.artery.enabled=on + """ + + val testConfig = ConfigFactory.parseString(serializationTestOverrides).withFallback(AkkaSpec.testConf) + + class TestException(msg: String) extends RuntimeException { + override def equals(other: Any): Boolean = other match { + case e: TestException ⇒ e.getMessage == getMessage + case _ ⇒ false + } + } +} + +class SystemMessageSerializationSpec extends AkkaSpec(PrimitivesSerializationSpec.testConfig) { + import SystemMessageSerializationSpec._ + + val testRef = TestProbe().ref.asInstanceOf[InternalActorRef] + val testRef2 = TestProbe().ref.asInstanceOf[InternalActorRef] + + "ByteStringSerializer" must { + Seq( + "Create(None)" → Create(None), + "Recreate(ex)" → Recreate(new TestException("test2")), + "Suspend()" → Suspend(), + "Resume(ex)" → Resume(new TestException("test3")), + "Terminate()" → Terminate(), + "Supervise(ref, async)" → Supervise(testRef, async = true), + "Watch(ref, ref)" → Watch(testRef, testRef2), + "Unwatch(ref, ref)" → Unwatch(testRef, testRef2), + "Failed(ref, ex, uid)" → Failed(testRef, new TestException("test4"), 42), + "DeathWatchNotification(ref, confimed, addressTerminated)" → + DeathWatchNotification(testRef, existenceConfirmed = true, addressTerminated = true) + ).foreach { + case (scenario, item) ⇒ + s"resolve serializer for [$scenario]" in { + val serializer = SerializationExtension(system) + serializer.serializerFor(item.getClass).getClass should ===(classOf[SystemMessageSerializer]) + } + + s"serialize and de-serialize [$scenario]" in { + verifySerialization(item) + } + } + + def verifySerialization(msg: AnyRef): Unit = { + val serializer = new SystemMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) + serializer.fromBinary(serializer.toBinary(msg), None) should ===(msg) + } + + // ActorInitializationException has no proper equality + "serialize and de-serialize Create(Some(ex))" in { + val aiex = ActorInitializationException(testRef, "test", new TestException("test5")) + val createMsg = Create(Some(aiex)) + val serializer = new SystemMessageSerializer(system.asInstanceOf[ExtendedActorSystem]) + val deserialized = serializer.fromBinary(serializer.toBinary(createMsg), None).asInstanceOf[Create] + + deserialized.failure.get.getCause should ===(aiex.getCause) + deserialized.failure.get.getMessage should ===(aiex.getMessage) + deserialized.failure.get.getActor should ===(aiex.getActor) + + } + + } + +}