6067 lines
230 KiB
Java
6067 lines
230 KiB
Java
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: RemoteProtocol.proto
|
|
|
|
package akka.remote.protocol;
|
|
|
|
public final class RemoteProtocol {
|
|
private RemoteProtocol() {}
|
|
public static void registerAllExtensions(
|
|
com.google.protobuf.ExtensionRegistry registry) {
|
|
}
|
|
public enum CommandType
|
|
implements com.google.protobuf.ProtocolMessageEnum {
|
|
CONNECT(0, 1),
|
|
SHUTDOWN(1, 2),
|
|
;
|
|
|
|
|
|
public final int getNumber() { return value; }
|
|
|
|
public static CommandType valueOf(int value) {
|
|
switch (value) {
|
|
case 1: return CONNECT;
|
|
case 2: return SHUTDOWN;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public static com.google.protobuf.Internal.EnumLiteMap<CommandType>
|
|
internalGetValueMap() {
|
|
return internalValueMap;
|
|
}
|
|
private static com.google.protobuf.Internal.EnumLiteMap<CommandType>
|
|
internalValueMap =
|
|
new com.google.protobuf.Internal.EnumLiteMap<CommandType>() {
|
|
public CommandType findValueByNumber(int number) {
|
|
return CommandType.valueOf(number)
|
|
; }
|
|
};
|
|
|
|
public final com.google.protobuf.Descriptors.EnumValueDescriptor
|
|
getValueDescriptor() {
|
|
return getDescriptor().getValues().get(index);
|
|
}
|
|
public final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptorForType() {
|
|
return getDescriptor();
|
|
}
|
|
public static final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(0);
|
|
}
|
|
|
|
private static final CommandType[] VALUES = {
|
|
CONNECT, SHUTDOWN,
|
|
};
|
|
public static CommandType valueOf(
|
|
com.google.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 CommandType(int index, int value) {
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
static {
|
|
akka.remote.protocol.RemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
// @@protoc_insertion_point(enum_scope:CommandType)
|
|
}
|
|
|
|
public enum ReplicationStorageType
|
|
implements com.google.protobuf.ProtocolMessageEnum {
|
|
TRANSIENT(0, 1),
|
|
TRANSACTION_LOG(1, 2),
|
|
DATA_GRID(2, 3),
|
|
;
|
|
|
|
|
|
public final int getNumber() { return value; }
|
|
|
|
public static ReplicationStorageType valueOf(int value) {
|
|
switch (value) {
|
|
case 1: return TRANSIENT;
|
|
case 2: return TRANSACTION_LOG;
|
|
case 3: return DATA_GRID;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public static com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>
|
|
internalGetValueMap() {
|
|
return internalValueMap;
|
|
}
|
|
private static com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>
|
|
internalValueMap =
|
|
new com.google.protobuf.Internal.EnumLiteMap<ReplicationStorageType>() {
|
|
public ReplicationStorageType findValueByNumber(int number) {
|
|
return ReplicationStorageType.valueOf(number)
|
|
; }
|
|
};
|
|
|
|
public final com.google.protobuf.Descriptors.EnumValueDescriptor
|
|
getValueDescriptor() {
|
|
return getDescriptor().getValues().get(index);
|
|
}
|
|
public final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptorForType() {
|
|
return getDescriptor();
|
|
}
|
|
public static final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(1);
|
|
}
|
|
|
|
private static final ReplicationStorageType[] VALUES = {
|
|
TRANSIENT, TRANSACTION_LOG, DATA_GRID,
|
|
};
|
|
public static ReplicationStorageType valueOf(
|
|
com.google.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 ReplicationStorageType(int index, int value) {
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
static {
|
|
akka.remote.protocol.RemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
// @@protoc_insertion_point(enum_scope:ReplicationStorageType)
|
|
}
|
|
|
|
public enum ReplicationStrategyType
|
|
implements com.google.protobuf.ProtocolMessageEnum {
|
|
WRITE_THROUGH(0, 1),
|
|
WRITE_BEHIND(1, 2),
|
|
;
|
|
|
|
|
|
public final int getNumber() { return value; }
|
|
|
|
public static ReplicationStrategyType valueOf(int value) {
|
|
switch (value) {
|
|
case 1: return WRITE_THROUGH;
|
|
case 2: return WRITE_BEHIND;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public static com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>
|
|
internalGetValueMap() {
|
|
return internalValueMap;
|
|
}
|
|
private static com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>
|
|
internalValueMap =
|
|
new com.google.protobuf.Internal.EnumLiteMap<ReplicationStrategyType>() {
|
|
public ReplicationStrategyType findValueByNumber(int number) {
|
|
return ReplicationStrategyType.valueOf(number)
|
|
; }
|
|
};
|
|
|
|
public final com.google.protobuf.Descriptors.EnumValueDescriptor
|
|
getValueDescriptor() {
|
|
return getDescriptor().getValues().get(index);
|
|
}
|
|
public final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptorForType() {
|
|
return getDescriptor();
|
|
}
|
|
public static final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(2);
|
|
}
|
|
|
|
private static final ReplicationStrategyType[] VALUES = {
|
|
WRITE_THROUGH, WRITE_BEHIND,
|
|
};
|
|
public static ReplicationStrategyType valueOf(
|
|
com.google.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 ReplicationStrategyType(int index, int value) {
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
static {
|
|
akka.remote.protocol.RemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
// @@protoc_insertion_point(enum_scope:ReplicationStrategyType)
|
|
}
|
|
|
|
public enum SerializationSchemeType
|
|
implements com.google.protobuf.ProtocolMessageEnum {
|
|
JAVA(0, 1),
|
|
SBINARY(1, 2),
|
|
SCALA_JSON(2, 3),
|
|
JAVA_JSON(3, 4),
|
|
PROTOBUF(4, 5),
|
|
;
|
|
|
|
|
|
public final int getNumber() { return value; }
|
|
|
|
public static SerializationSchemeType valueOf(int value) {
|
|
switch (value) {
|
|
case 1: return JAVA;
|
|
case 2: return SBINARY;
|
|
case 3: return SCALA_JSON;
|
|
case 4: return JAVA_JSON;
|
|
case 5: return PROTOBUF;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public static com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>
|
|
internalGetValueMap() {
|
|
return internalValueMap;
|
|
}
|
|
private static com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>
|
|
internalValueMap =
|
|
new com.google.protobuf.Internal.EnumLiteMap<SerializationSchemeType>() {
|
|
public SerializationSchemeType findValueByNumber(int number) {
|
|
return SerializationSchemeType.valueOf(number)
|
|
; }
|
|
};
|
|
|
|
public final com.google.protobuf.Descriptors.EnumValueDescriptor
|
|
getValueDescriptor() {
|
|
return getDescriptor().getValues().get(index);
|
|
}
|
|
public final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptorForType() {
|
|
return getDescriptor();
|
|
}
|
|
public static final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(3);
|
|
}
|
|
|
|
private static final SerializationSchemeType[] VALUES = {
|
|
JAVA, SBINARY, SCALA_JSON, JAVA_JSON, PROTOBUF,
|
|
};
|
|
public static SerializationSchemeType valueOf(
|
|
com.google.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 SerializationSchemeType(int index, int value) {
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
static {
|
|
akka.remote.protocol.RemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
// @@protoc_insertion_point(enum_scope:SerializationSchemeType)
|
|
}
|
|
|
|
public enum LifeCycleType
|
|
implements com.google.protobuf.ProtocolMessageEnum {
|
|
PERMANENT(0, 1),
|
|
TEMPORARY(1, 2),
|
|
;
|
|
|
|
|
|
public final int getNumber() { return value; }
|
|
|
|
public static LifeCycleType valueOf(int value) {
|
|
switch (value) {
|
|
case 1: return PERMANENT;
|
|
case 2: return TEMPORARY;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
public static com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>
|
|
internalGetValueMap() {
|
|
return internalValueMap;
|
|
}
|
|
private static com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>
|
|
internalValueMap =
|
|
new com.google.protobuf.Internal.EnumLiteMap<LifeCycleType>() {
|
|
public LifeCycleType findValueByNumber(int number) {
|
|
return LifeCycleType.valueOf(number)
|
|
; }
|
|
};
|
|
|
|
public final com.google.protobuf.Descriptors.EnumValueDescriptor
|
|
getValueDescriptor() {
|
|
return getDescriptor().getValues().get(index);
|
|
}
|
|
public final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptorForType() {
|
|
return getDescriptor();
|
|
}
|
|
public static final com.google.protobuf.Descriptors.EnumDescriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.getDescriptor().getEnumTypes().get(4);
|
|
}
|
|
|
|
private static final LifeCycleType[] VALUES = {
|
|
PERMANENT, TEMPORARY,
|
|
};
|
|
public static LifeCycleType valueOf(
|
|
com.google.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 LifeCycleType(int index, int value) {
|
|
this.index = index;
|
|
this.value = value;
|
|
}
|
|
|
|
static {
|
|
akka.remote.protocol.RemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
// @@protoc_insertion_point(enum_scope:LifeCycleType)
|
|
}
|
|
|
|
public static final class AkkaRemoteProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use AkkaRemoteProtocol.newBuilder() to construct.
|
|
private AkkaRemoteProtocol() {
|
|
initFields();
|
|
}
|
|
private AkkaRemoteProtocol(boolean noInit) {}
|
|
|
|
private static final AkkaRemoteProtocol defaultInstance;
|
|
public static AkkaRemoteProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public AkkaRemoteProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_AkkaRemoteProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_AkkaRemoteProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// optional .RemoteMessageProtocol message = 1;
|
|
public static final int MESSAGE_FIELD_NUMBER = 1;
|
|
private boolean hasMessage;
|
|
private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol message_;
|
|
public boolean hasMessage() { return hasMessage; }
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessage() { return message_; }
|
|
|
|
// optional .RemoteControlProtocol instruction = 2;
|
|
public static final int INSTRUCTION_FIELD_NUMBER = 2;
|
|
private boolean hasInstruction;
|
|
private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol instruction_;
|
|
public boolean hasInstruction() { return hasInstruction; }
|
|
public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getInstruction() { return instruction_; }
|
|
|
|
private void initFields() {
|
|
message_ = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
|
|
instruction_ = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (hasMessage()) {
|
|
if (!getMessage().isInitialized()) return false;
|
|
}
|
|
if (hasInstruction()) {
|
|
if (!getInstruction().isInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasMessage()) {
|
|
output.writeMessage(1, getMessage());
|
|
}
|
|
if (hasInstruction()) {
|
|
output.writeMessage(2, getInstruction());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasMessage()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(1, getMessage());
|
|
}
|
|
if (hasInstruction()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(2, getInstruction());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
|
|
if (other.hasMessage()) {
|
|
mergeMessage(other.getMessage());
|
|
}
|
|
if (other.hasInstruction()) {
|
|
mergeInstruction(other.getInstruction());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder();
|
|
if (hasMessage()) {
|
|
subBuilder.mergeFrom(getMessage());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setMessage(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 18: {
|
|
akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder();
|
|
if (hasInstruction()) {
|
|
subBuilder.mergeFrom(getInstruction());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setInstruction(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// optional .RemoteMessageProtocol message = 1;
|
|
public boolean hasMessage() {
|
|
return result.hasMessage();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessage() {
|
|
return result.getMessage();
|
|
}
|
|
public Builder setMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasMessage = true;
|
|
result.message_ = value;
|
|
return this;
|
|
}
|
|
public Builder setMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
|
|
result.hasMessage = true;
|
|
result.message_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeMessage(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
|
|
if (result.hasMessage() &&
|
|
result.message_ != akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) {
|
|
result.message_ =
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder(result.message_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.message_ = value;
|
|
}
|
|
result.hasMessage = true;
|
|
return this;
|
|
}
|
|
public Builder clearMessage() {
|
|
result.hasMessage = false;
|
|
result.message_ = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional .RemoteControlProtocol instruction = 2;
|
|
public boolean hasInstruction() {
|
|
return result.hasInstruction();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getInstruction() {
|
|
return result.getInstruction();
|
|
}
|
|
public Builder setInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasInstruction = true;
|
|
result.instruction_ = value;
|
|
return this;
|
|
}
|
|
public Builder setInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder builderForValue) {
|
|
result.hasInstruction = true;
|
|
result.instruction_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeInstruction(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol value) {
|
|
if (result.hasInstruction() &&
|
|
result.instruction_ != akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) {
|
|
result.instruction_ =
|
|
akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder(result.instruction_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.instruction_ = value;
|
|
}
|
|
result.hasInstruction = true;
|
|
return this;
|
|
}
|
|
public Builder clearInstruction() {
|
|
result.hasInstruction = false;
|
|
result.instruction_ = akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:AkkaRemoteProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new AkkaRemoteProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:AkkaRemoteProtocol)
|
|
}
|
|
|
|
public static final class RemoteMessageProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use RemoteMessageProtocol.newBuilder() to construct.
|
|
private RemoteMessageProtocol() {
|
|
initFields();
|
|
}
|
|
private RemoteMessageProtocol(boolean noInit) {}
|
|
|
|
private static final RemoteMessageProtocol defaultInstance;
|
|
public static RemoteMessageProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public RemoteMessageProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public static final int UUID_FIELD_NUMBER = 1;
|
|
private boolean hasUuid;
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
|
|
public boolean hasUuid() { return hasUuid; }
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
|
|
|
|
// required .ActorInfoProtocol actorInfo = 2;
|
|
public static final int ACTORINFO_FIELD_NUMBER = 2;
|
|
private boolean hasActorInfo;
|
|
private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol actorInfo_;
|
|
public boolean hasActorInfo() { return hasActorInfo; }
|
|
public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getActorInfo() { return actorInfo_; }
|
|
|
|
// required bool oneWay = 3;
|
|
public static final int ONEWAY_FIELD_NUMBER = 3;
|
|
private boolean hasOneWay;
|
|
private boolean oneWay_ = false;
|
|
public boolean hasOneWay() { return hasOneWay; }
|
|
public boolean getOneWay() { return oneWay_; }
|
|
|
|
// optional .MessageProtocol message = 4;
|
|
public static final int MESSAGE_FIELD_NUMBER = 4;
|
|
private boolean hasMessage;
|
|
private akka.remote.protocol.RemoteProtocol.MessageProtocol message_;
|
|
public boolean hasMessage() { return hasMessage; }
|
|
public akka.remote.protocol.RemoteProtocol.MessageProtocol getMessage() { return message_; }
|
|
|
|
// optional .ExceptionProtocol exception = 5;
|
|
public static final int EXCEPTION_FIELD_NUMBER = 5;
|
|
private boolean hasException;
|
|
private akka.remote.protocol.RemoteProtocol.ExceptionProtocol exception_;
|
|
public boolean hasException() { return hasException; }
|
|
public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getException() { return exception_; }
|
|
|
|
// optional .UuidProtocol supervisorUuid = 6;
|
|
public static final int SUPERVISORUUID_FIELD_NUMBER = 6;
|
|
private boolean hasSupervisorUuid;
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol supervisorUuid_;
|
|
public boolean hasSupervisorUuid() { return hasSupervisorUuid; }
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getSupervisorUuid() { return supervisorUuid_; }
|
|
|
|
// optional .RemoteActorRefProtocol sender = 7;
|
|
public static final int SENDER_FIELD_NUMBER = 7;
|
|
private boolean hasSender;
|
|
private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol sender_;
|
|
public boolean hasSender() { return hasSender; }
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSender() { return sender_; }
|
|
|
|
// repeated .MetadataEntryProtocol metadata = 8;
|
|
public static final int METADATA_FIELD_NUMBER = 8;
|
|
private java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> metadata_ =
|
|
java.util.Collections.emptyList();
|
|
public java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
|
|
return metadata_;
|
|
}
|
|
public int getMetadataCount() { return metadata_.size(); }
|
|
public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
|
|
return metadata_.get(index);
|
|
}
|
|
|
|
private void initFields() {
|
|
uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
actorInfo_ = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
|
|
message_ = akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
|
|
exception_ = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
|
|
supervisorUuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
sender_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasUuid) return false;
|
|
if (!hasActorInfo) return false;
|
|
if (!hasOneWay) return false;
|
|
if (!getUuid().isInitialized()) return false;
|
|
if (!getActorInfo().isInitialized()) return false;
|
|
if (hasMessage()) {
|
|
if (!getMessage().isInitialized()) return false;
|
|
}
|
|
if (hasException()) {
|
|
if (!getException().isInitialized()) return false;
|
|
}
|
|
if (hasSupervisorUuid()) {
|
|
if (!getSupervisorUuid().isInitialized()) return false;
|
|
}
|
|
if (hasSender()) {
|
|
if (!getSender().isInitialized()) return false;
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
|
|
if (!element.isInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasUuid()) {
|
|
output.writeMessage(1, getUuid());
|
|
}
|
|
if (hasActorInfo()) {
|
|
output.writeMessage(2, getActorInfo());
|
|
}
|
|
if (hasOneWay()) {
|
|
output.writeBool(3, getOneWay());
|
|
}
|
|
if (hasMessage()) {
|
|
output.writeMessage(4, getMessage());
|
|
}
|
|
if (hasException()) {
|
|
output.writeMessage(5, getException());
|
|
}
|
|
if (hasSupervisorUuid()) {
|
|
output.writeMessage(6, getSupervisorUuid());
|
|
}
|
|
if (hasSender()) {
|
|
output.writeMessage(7, getSender());
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
|
|
output.writeMessage(8, element);
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasUuid()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(1, getUuid());
|
|
}
|
|
if (hasActorInfo()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(2, getActorInfo());
|
|
}
|
|
if (hasOneWay()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBoolSize(3, getOneWay());
|
|
}
|
|
if (hasMessage()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(4, getMessage());
|
|
}
|
|
if (hasException()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(5, getException());
|
|
}
|
|
if (hasSupervisorUuid()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(6, getSupervisorUuid());
|
|
}
|
|
if (hasSender()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(7, getSender());
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol element : getMetadataList()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(8, element);
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
if (result.metadata_ != java.util.Collections.EMPTY_LIST) {
|
|
result.metadata_ =
|
|
java.util.Collections.unmodifiableList(result.metadata_);
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
|
|
if (other.hasUuid()) {
|
|
mergeUuid(other.getUuid());
|
|
}
|
|
if (other.hasActorInfo()) {
|
|
mergeActorInfo(other.getActorInfo());
|
|
}
|
|
if (other.hasOneWay()) {
|
|
setOneWay(other.getOneWay());
|
|
}
|
|
if (other.hasMessage()) {
|
|
mergeMessage(other.getMessage());
|
|
}
|
|
if (other.hasException()) {
|
|
mergeException(other.getException());
|
|
}
|
|
if (other.hasSupervisorUuid()) {
|
|
mergeSupervisorUuid(other.getSupervisorUuid());
|
|
}
|
|
if (other.hasSender()) {
|
|
mergeSender(other.getSender());
|
|
}
|
|
if (!other.metadata_.isEmpty()) {
|
|
if (result.metadata_.isEmpty()) {
|
|
result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
|
|
}
|
|
result.metadata_.addAll(other.metadata_);
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
|
|
if (hasUuid()) {
|
|
subBuilder.mergeFrom(getUuid());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setUuid(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 18: {
|
|
akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder();
|
|
if (hasActorInfo()) {
|
|
subBuilder.mergeFrom(getActorInfo());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setActorInfo(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 24: {
|
|
setOneWay(input.readBool());
|
|
break;
|
|
}
|
|
case 34: {
|
|
akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder();
|
|
if (hasMessage()) {
|
|
subBuilder.mergeFrom(getMessage());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setMessage(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 42: {
|
|
akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder();
|
|
if (hasException()) {
|
|
subBuilder.mergeFrom(getException());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setException(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 50: {
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
|
|
if (hasSupervisorUuid()) {
|
|
subBuilder.mergeFrom(getSupervisorUuid());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setSupervisorUuid(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 58: {
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
|
|
if (hasSender()) {
|
|
subBuilder.mergeFrom(getSender());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setSender(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 66: {
|
|
akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.newBuilder();
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
addMetadata(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public boolean hasUuid() {
|
|
return result.hasUuid();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
|
|
return result.getUuid();
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasUuid = true;
|
|
result.uuid_ = value;
|
|
return this;
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
|
|
result.hasUuid = true;
|
|
result.uuid_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (result.hasUuid() &&
|
|
result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
|
|
result.uuid_ =
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.uuid_ = value;
|
|
}
|
|
result.hasUuid = true;
|
|
return this;
|
|
}
|
|
public Builder clearUuid() {
|
|
result.hasUuid = false;
|
|
result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// required .ActorInfoProtocol actorInfo = 2;
|
|
public boolean hasActorInfo() {
|
|
return result.hasActorInfo();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getActorInfo() {
|
|
return result.getActorInfo();
|
|
}
|
|
public Builder setActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasActorInfo = true;
|
|
result.actorInfo_ = value;
|
|
return this;
|
|
}
|
|
public Builder setActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder builderForValue) {
|
|
result.hasActorInfo = true;
|
|
result.actorInfo_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeActorInfo(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol value) {
|
|
if (result.hasActorInfo() &&
|
|
result.actorInfo_ != akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) {
|
|
result.actorInfo_ =
|
|
akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder(result.actorInfo_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.actorInfo_ = value;
|
|
}
|
|
result.hasActorInfo = true;
|
|
return this;
|
|
}
|
|
public Builder clearActorInfo() {
|
|
result.hasActorInfo = false;
|
|
result.actorInfo_ = akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// required bool oneWay = 3;
|
|
public boolean hasOneWay() {
|
|
return result.hasOneWay();
|
|
}
|
|
public boolean getOneWay() {
|
|
return result.getOneWay();
|
|
}
|
|
public Builder setOneWay(boolean value) {
|
|
result.hasOneWay = true;
|
|
result.oneWay_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearOneWay() {
|
|
result.hasOneWay = false;
|
|
result.oneWay_ = false;
|
|
return this;
|
|
}
|
|
|
|
// optional .MessageProtocol message = 4;
|
|
public boolean hasMessage() {
|
|
return result.hasMessage();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.MessageProtocol getMessage() {
|
|
return result.getMessage();
|
|
}
|
|
public Builder setMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasMessage = true;
|
|
result.message_ = value;
|
|
return this;
|
|
}
|
|
public Builder setMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder builderForValue) {
|
|
result.hasMessage = true;
|
|
result.message_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeMessage(akka.remote.protocol.RemoteProtocol.MessageProtocol value) {
|
|
if (result.hasMessage() &&
|
|
result.message_ != akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance()) {
|
|
result.message_ =
|
|
akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder(result.message_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.message_ = value;
|
|
}
|
|
result.hasMessage = true;
|
|
return this;
|
|
}
|
|
public Builder clearMessage() {
|
|
result.hasMessage = false;
|
|
result.message_ = akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional .ExceptionProtocol exception = 5;
|
|
public boolean hasException() {
|
|
return result.hasException();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getException() {
|
|
return result.getException();
|
|
}
|
|
public Builder setException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasException = true;
|
|
result.exception_ = value;
|
|
return this;
|
|
}
|
|
public Builder setException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder builderForValue) {
|
|
result.hasException = true;
|
|
result.exception_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeException(akka.remote.protocol.RemoteProtocol.ExceptionProtocol value) {
|
|
if (result.hasException() &&
|
|
result.exception_ != akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) {
|
|
result.exception_ =
|
|
akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder(result.exception_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.exception_ = value;
|
|
}
|
|
result.hasException = true;
|
|
return this;
|
|
}
|
|
public Builder clearException() {
|
|
result.hasException = false;
|
|
result.exception_ = akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional .UuidProtocol supervisorUuid = 6;
|
|
public boolean hasSupervisorUuid() {
|
|
return result.hasSupervisorUuid();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getSupervisorUuid() {
|
|
return result.getSupervisorUuid();
|
|
}
|
|
public Builder setSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasSupervisorUuid = true;
|
|
result.supervisorUuid_ = value;
|
|
return this;
|
|
}
|
|
public Builder setSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
|
|
result.hasSupervisorUuid = true;
|
|
result.supervisorUuid_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeSupervisorUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (result.hasSupervisorUuid() &&
|
|
result.supervisorUuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
|
|
result.supervisorUuid_ =
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.supervisorUuid_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.supervisorUuid_ = value;
|
|
}
|
|
result.hasSupervisorUuid = true;
|
|
return this;
|
|
}
|
|
public Builder clearSupervisorUuid() {
|
|
result.hasSupervisorUuid = false;
|
|
result.supervisorUuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional .RemoteActorRefProtocol sender = 7;
|
|
public boolean hasSender() {
|
|
return result.hasSender();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSender() {
|
|
return result.getSender();
|
|
}
|
|
public Builder setSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasSender = true;
|
|
result.sender_ = value;
|
|
return this;
|
|
}
|
|
public Builder setSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
|
|
result.hasSender = true;
|
|
result.sender_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeSender(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
|
|
if (result.hasSender() &&
|
|
result.sender_ != akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
|
|
result.sender_ =
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder(result.sender_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.sender_ = value;
|
|
}
|
|
result.hasSender = true;
|
|
return this;
|
|
}
|
|
public Builder clearSender() {
|
|
result.hasSender = false;
|
|
result.sender_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// repeated .MetadataEntryProtocol metadata = 8;
|
|
public java.util.List<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
|
|
return java.util.Collections.unmodifiableList(result.metadata_);
|
|
}
|
|
public int getMetadataCount() {
|
|
return result.getMetadataCount();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getMetadata(int index) {
|
|
return result.getMetadata(index);
|
|
}
|
|
public Builder setMetadata(int index, akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.metadata_.set(index, value);
|
|
return this;
|
|
}
|
|
public Builder setMetadata(int index, akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
|
|
result.metadata_.set(index, builderForValue.build());
|
|
return this;
|
|
}
|
|
public Builder addMetadata(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
if (result.metadata_.isEmpty()) {
|
|
result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
|
|
}
|
|
result.metadata_.add(value);
|
|
return this;
|
|
}
|
|
public Builder addMetadata(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder builderForValue) {
|
|
if (result.metadata_.isEmpty()) {
|
|
result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
|
|
}
|
|
result.metadata_.add(builderForValue.build());
|
|
return this;
|
|
}
|
|
public Builder addAllMetadata(
|
|
java.lang.Iterable<? extends akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol> values) {
|
|
if (result.metadata_.isEmpty()) {
|
|
result.metadata_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol>();
|
|
}
|
|
super.addAll(values, result.metadata_);
|
|
return this;
|
|
}
|
|
public Builder clearMetadata() {
|
|
result.metadata_ = java.util.Collections.emptyList();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:RemoteMessageProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new RemoteMessageProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:RemoteMessageProtocol)
|
|
}
|
|
|
|
public static final class RemoteControlProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use RemoteControlProtocol.newBuilder() to construct.
|
|
private RemoteControlProtocol() {
|
|
initFields();
|
|
}
|
|
private RemoteControlProtocol(boolean noInit) {}
|
|
|
|
private static final RemoteControlProtocol defaultInstance;
|
|
public static RemoteControlProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public RemoteControlProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// optional string cookie = 1;
|
|
public static final int COOKIE_FIELD_NUMBER = 1;
|
|
private boolean hasCookie;
|
|
private java.lang.String cookie_ = "";
|
|
public boolean hasCookie() { return hasCookie; }
|
|
public java.lang.String getCookie() { return cookie_; }
|
|
|
|
// required .CommandType commandType = 2;
|
|
public static final int COMMANDTYPE_FIELD_NUMBER = 2;
|
|
private boolean hasCommandType;
|
|
private akka.remote.protocol.RemoteProtocol.CommandType commandType_;
|
|
public boolean hasCommandType() { return hasCommandType; }
|
|
public akka.remote.protocol.RemoteProtocol.CommandType getCommandType() { return commandType_; }
|
|
|
|
private void initFields() {
|
|
commandType_ = akka.remote.protocol.RemoteProtocol.CommandType.CONNECT;
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasCommandType) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasCookie()) {
|
|
output.writeString(1, getCookie());
|
|
}
|
|
if (hasCommandType()) {
|
|
output.writeEnum(2, getCommandType().getNumber());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasCookie()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(1, getCookie());
|
|
}
|
|
if (hasCommandType()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeEnumSize(2, getCommandType().getNumber());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteControlProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.RemoteControlProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.RemoteControlProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.RemoteControlProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.RemoteControlProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteControlProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.RemoteControlProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteControlProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteControlProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteControlProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
|
|
if (other.hasCookie()) {
|
|
setCookie(other.getCookie());
|
|
}
|
|
if (other.hasCommandType()) {
|
|
setCommandType(other.getCommandType());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setCookie(input.readString());
|
|
break;
|
|
}
|
|
case 16: {
|
|
int rawValue = input.readEnum();
|
|
akka.remote.protocol.RemoteProtocol.CommandType value = akka.remote.protocol.RemoteProtocol.CommandType.valueOf(rawValue);
|
|
if (value == null) {
|
|
unknownFields.mergeVarintField(2, rawValue);
|
|
} else {
|
|
setCommandType(value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// optional string cookie = 1;
|
|
public boolean hasCookie() {
|
|
return result.hasCookie();
|
|
}
|
|
public java.lang.String getCookie() {
|
|
return result.getCookie();
|
|
}
|
|
public Builder setCookie(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasCookie = true;
|
|
result.cookie_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearCookie() {
|
|
result.hasCookie = false;
|
|
result.cookie_ = getDefaultInstance().getCookie();
|
|
return this;
|
|
}
|
|
|
|
// required .CommandType commandType = 2;
|
|
public boolean hasCommandType() {
|
|
return result.hasCommandType();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.CommandType getCommandType() {
|
|
return result.getCommandType();
|
|
}
|
|
public Builder setCommandType(akka.remote.protocol.RemoteProtocol.CommandType value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasCommandType = true;
|
|
result.commandType_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearCommandType() {
|
|
result.hasCommandType = false;
|
|
result.commandType_ = akka.remote.protocol.RemoteProtocol.CommandType.CONNECT;
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:RemoteControlProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new RemoteControlProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:RemoteControlProtocol)
|
|
}
|
|
|
|
public static final class RemoteActorRefProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use RemoteActorRefProtocol.newBuilder() to construct.
|
|
private RemoteActorRefProtocol() {
|
|
initFields();
|
|
}
|
|
private RemoteActorRefProtocol(boolean noInit) {}
|
|
|
|
private static final RemoteActorRefProtocol defaultInstance;
|
|
public static RemoteActorRefProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public RemoteActorRefProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteActorRefProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_RemoteActorRefProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required string address = 1;
|
|
public static final int ADDRESS_FIELD_NUMBER = 1;
|
|
private boolean hasAddress;
|
|
private java.lang.String address_ = "";
|
|
public boolean hasAddress() { return hasAddress; }
|
|
public java.lang.String getAddress() { return address_; }
|
|
|
|
// required bytes inetSocketAddress = 2;
|
|
public static final int INETSOCKETADDRESS_FIELD_NUMBER = 2;
|
|
private boolean hasInetSocketAddress;
|
|
private com.google.protobuf.ByteString inetSocketAddress_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasInetSocketAddress() { return hasInetSocketAddress; }
|
|
public com.google.protobuf.ByteString getInetSocketAddress() { return inetSocketAddress_; }
|
|
|
|
// optional uint64 timeout = 3;
|
|
public static final int TIMEOUT_FIELD_NUMBER = 3;
|
|
private boolean hasTimeout;
|
|
private long timeout_ = 0L;
|
|
public boolean hasTimeout() { return hasTimeout; }
|
|
public long getTimeout() { return timeout_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasAddress) return false;
|
|
if (!hasInetSocketAddress) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasAddress()) {
|
|
output.writeString(1, getAddress());
|
|
}
|
|
if (hasInetSocketAddress()) {
|
|
output.writeBytes(2, getInetSocketAddress());
|
|
}
|
|
if (hasTimeout()) {
|
|
output.writeUInt64(3, getTimeout());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasAddress()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(1, getAddress());
|
|
}
|
|
if (hasInetSocketAddress()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(2, getInetSocketAddress());
|
|
}
|
|
if (hasTimeout()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(3, getTimeout());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) return this;
|
|
if (other.hasAddress()) {
|
|
setAddress(other.getAddress());
|
|
}
|
|
if (other.hasInetSocketAddress()) {
|
|
setInetSocketAddress(other.getInetSocketAddress());
|
|
}
|
|
if (other.hasTimeout()) {
|
|
setTimeout(other.getTimeout());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setAddress(input.readString());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setInetSocketAddress(input.readBytes());
|
|
break;
|
|
}
|
|
case 24: {
|
|
setTimeout(input.readUInt64());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required string address = 1;
|
|
public boolean hasAddress() {
|
|
return result.hasAddress();
|
|
}
|
|
public java.lang.String getAddress() {
|
|
return result.getAddress();
|
|
}
|
|
public Builder setAddress(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasAddress = true;
|
|
result.address_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearAddress() {
|
|
result.hasAddress = false;
|
|
result.address_ = getDefaultInstance().getAddress();
|
|
return this;
|
|
}
|
|
|
|
// required bytes inetSocketAddress = 2;
|
|
public boolean hasInetSocketAddress() {
|
|
return result.hasInetSocketAddress();
|
|
}
|
|
public com.google.protobuf.ByteString getInetSocketAddress() {
|
|
return result.getInetSocketAddress();
|
|
}
|
|
public Builder setInetSocketAddress(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasInetSocketAddress = true;
|
|
result.inetSocketAddress_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearInetSocketAddress() {
|
|
result.hasInetSocketAddress = false;
|
|
result.inetSocketAddress_ = getDefaultInstance().getInetSocketAddress();
|
|
return this;
|
|
}
|
|
|
|
// optional uint64 timeout = 3;
|
|
public boolean hasTimeout() {
|
|
return result.hasTimeout();
|
|
}
|
|
public long getTimeout() {
|
|
return result.getTimeout();
|
|
}
|
|
public Builder setTimeout(long value) {
|
|
result.hasTimeout = true;
|
|
result.timeout_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearTimeout() {
|
|
result.hasTimeout = false;
|
|
result.timeout_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:RemoteActorRefProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new RemoteActorRefProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:RemoteActorRefProtocol)
|
|
}
|
|
|
|
public static final class SerializedActorRefProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use SerializedActorRefProtocol.newBuilder() to construct.
|
|
private SerializedActorRefProtocol() {
|
|
initFields();
|
|
}
|
|
private SerializedActorRefProtocol(boolean noInit) {}
|
|
|
|
private static final SerializedActorRefProtocol defaultInstance;
|
|
public static SerializedActorRefProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public SerializedActorRefProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_SerializedActorRefProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_SerializedActorRefProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public static final int UUID_FIELD_NUMBER = 1;
|
|
private boolean hasUuid;
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
|
|
public boolean hasUuid() { return hasUuid; }
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
|
|
|
|
// required string address = 2;
|
|
public static final int ADDRESS_FIELD_NUMBER = 2;
|
|
private boolean hasAddress;
|
|
private java.lang.String address_ = "";
|
|
public boolean hasAddress() { return hasAddress; }
|
|
public java.lang.String getAddress() { return address_; }
|
|
|
|
// required string actorClassname = 3;
|
|
public static final int ACTORCLASSNAME_FIELD_NUMBER = 3;
|
|
private boolean hasActorClassname;
|
|
private java.lang.String actorClassname_ = "";
|
|
public boolean hasActorClassname() { return hasActorClassname; }
|
|
public java.lang.String getActorClassname() { return actorClassname_; }
|
|
|
|
// optional bytes actorInstance = 4;
|
|
public static final int ACTORINSTANCE_FIELD_NUMBER = 4;
|
|
private boolean hasActorInstance;
|
|
private com.google.protobuf.ByteString actorInstance_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasActorInstance() { return hasActorInstance; }
|
|
public com.google.protobuf.ByteString getActorInstance() { return actorInstance_; }
|
|
|
|
// optional string serializerClassname = 5;
|
|
public static final int SERIALIZERCLASSNAME_FIELD_NUMBER = 5;
|
|
private boolean hasSerializerClassname;
|
|
private java.lang.String serializerClassname_ = "";
|
|
public boolean hasSerializerClassname() { return hasSerializerClassname; }
|
|
public java.lang.String getSerializerClassname() { return serializerClassname_; }
|
|
|
|
// optional uint64 timeout = 6;
|
|
public static final int TIMEOUT_FIELD_NUMBER = 6;
|
|
private boolean hasTimeout;
|
|
private long timeout_ = 0L;
|
|
public boolean hasTimeout() { return hasTimeout; }
|
|
public long getTimeout() { return timeout_; }
|
|
|
|
// optional uint64 receiveTimeout = 7;
|
|
public static final int RECEIVETIMEOUT_FIELD_NUMBER = 7;
|
|
private boolean hasReceiveTimeout;
|
|
private long receiveTimeout_ = 0L;
|
|
public boolean hasReceiveTimeout() { return hasReceiveTimeout; }
|
|
public long getReceiveTimeout() { return receiveTimeout_; }
|
|
|
|
// optional .LifeCycleProtocol lifeCycle = 8;
|
|
public static final int LIFECYCLE_FIELD_NUMBER = 8;
|
|
private boolean hasLifeCycle;
|
|
private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol lifeCycle_;
|
|
public boolean hasLifeCycle() { return hasLifeCycle; }
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getLifeCycle() { return lifeCycle_; }
|
|
|
|
// optional .RemoteActorRefProtocol supervisor = 9;
|
|
public static final int SUPERVISOR_FIELD_NUMBER = 9;
|
|
private boolean hasSupervisor;
|
|
private akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol supervisor_;
|
|
public boolean hasSupervisor() { return hasSupervisor; }
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSupervisor() { return supervisor_; }
|
|
|
|
// optional bytes hotswapStack = 10;
|
|
public static final int HOTSWAPSTACK_FIELD_NUMBER = 10;
|
|
private boolean hasHotswapStack;
|
|
private com.google.protobuf.ByteString hotswapStack_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasHotswapStack() { return hasHotswapStack; }
|
|
public com.google.protobuf.ByteString getHotswapStack() { return hotswapStack_; }
|
|
|
|
// optional .ReplicationStorageType replicationStorage = 11;
|
|
public static final int REPLICATIONSTORAGE_FIELD_NUMBER = 11;
|
|
private boolean hasReplicationStorage;
|
|
private akka.remote.protocol.RemoteProtocol.ReplicationStorageType replicationStorage_;
|
|
public boolean hasReplicationStorage() { return hasReplicationStorage; }
|
|
public akka.remote.protocol.RemoteProtocol.ReplicationStorageType getReplicationStorage() { return replicationStorage_; }
|
|
|
|
// optional .ReplicationStrategyType replicationStrategy = 12;
|
|
public static final int REPLICATIONSTRATEGY_FIELD_NUMBER = 12;
|
|
private boolean hasReplicationStrategy;
|
|
private akka.remote.protocol.RemoteProtocol.ReplicationStrategyType replicationStrategy_;
|
|
public boolean hasReplicationStrategy() { return hasReplicationStrategy; }
|
|
public akka.remote.protocol.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() { return replicationStrategy_; }
|
|
|
|
// repeated .RemoteMessageProtocol messages = 13;
|
|
public static final int MESSAGES_FIELD_NUMBER = 13;
|
|
private java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> messages_ =
|
|
java.util.Collections.emptyList();
|
|
public java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
|
|
return messages_;
|
|
}
|
|
public int getMessagesCount() { return messages_.size(); }
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
|
|
return messages_.get(index);
|
|
}
|
|
|
|
private void initFields() {
|
|
uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
|
|
supervisor_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
|
|
replicationStorage_ = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.TRANSIENT;
|
|
replicationStrategy_ = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasUuid) return false;
|
|
if (!hasAddress) return false;
|
|
if (!hasActorClassname) return false;
|
|
if (!getUuid().isInitialized()) return false;
|
|
if (hasLifeCycle()) {
|
|
if (!getLifeCycle().isInitialized()) return false;
|
|
}
|
|
if (hasSupervisor()) {
|
|
if (!getSupervisor().isInitialized()) return false;
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
|
|
if (!element.isInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasUuid()) {
|
|
output.writeMessage(1, getUuid());
|
|
}
|
|
if (hasAddress()) {
|
|
output.writeString(2, getAddress());
|
|
}
|
|
if (hasActorClassname()) {
|
|
output.writeString(3, getActorClassname());
|
|
}
|
|
if (hasActorInstance()) {
|
|
output.writeBytes(4, getActorInstance());
|
|
}
|
|
if (hasSerializerClassname()) {
|
|
output.writeString(5, getSerializerClassname());
|
|
}
|
|
if (hasTimeout()) {
|
|
output.writeUInt64(6, getTimeout());
|
|
}
|
|
if (hasReceiveTimeout()) {
|
|
output.writeUInt64(7, getReceiveTimeout());
|
|
}
|
|
if (hasLifeCycle()) {
|
|
output.writeMessage(8, getLifeCycle());
|
|
}
|
|
if (hasSupervisor()) {
|
|
output.writeMessage(9, getSupervisor());
|
|
}
|
|
if (hasHotswapStack()) {
|
|
output.writeBytes(10, getHotswapStack());
|
|
}
|
|
if (hasReplicationStorage()) {
|
|
output.writeEnum(11, getReplicationStorage().getNumber());
|
|
}
|
|
if (hasReplicationStrategy()) {
|
|
output.writeEnum(12, getReplicationStrategy().getNumber());
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
|
|
output.writeMessage(13, element);
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasUuid()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(1, getUuid());
|
|
}
|
|
if (hasAddress()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(2, getAddress());
|
|
}
|
|
if (hasActorClassname()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(3, getActorClassname());
|
|
}
|
|
if (hasActorInstance()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(4, getActorInstance());
|
|
}
|
|
if (hasSerializerClassname()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(5, getSerializerClassname());
|
|
}
|
|
if (hasTimeout()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(6, getTimeout());
|
|
}
|
|
if (hasReceiveTimeout()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(7, getReceiveTimeout());
|
|
}
|
|
if (hasLifeCycle()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(8, getLifeCycle());
|
|
}
|
|
if (hasSupervisor()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(9, getSupervisor());
|
|
}
|
|
if (hasHotswapStack()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(10, getHotswapStack());
|
|
}
|
|
if (hasReplicationStorage()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeEnumSize(11, getReplicationStorage().getNumber());
|
|
}
|
|
if (hasReplicationStrategy()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeEnumSize(12, getReplicationStrategy().getNumber());
|
|
}
|
|
for (akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol element : getMessagesList()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(13, element);
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
if (result.messages_ != java.util.Collections.EMPTY_LIST) {
|
|
result.messages_ =
|
|
java.util.Collections.unmodifiableList(result.messages_);
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) return this;
|
|
if (other.hasUuid()) {
|
|
mergeUuid(other.getUuid());
|
|
}
|
|
if (other.hasAddress()) {
|
|
setAddress(other.getAddress());
|
|
}
|
|
if (other.hasActorClassname()) {
|
|
setActorClassname(other.getActorClassname());
|
|
}
|
|
if (other.hasActorInstance()) {
|
|
setActorInstance(other.getActorInstance());
|
|
}
|
|
if (other.hasSerializerClassname()) {
|
|
setSerializerClassname(other.getSerializerClassname());
|
|
}
|
|
if (other.hasTimeout()) {
|
|
setTimeout(other.getTimeout());
|
|
}
|
|
if (other.hasReceiveTimeout()) {
|
|
setReceiveTimeout(other.getReceiveTimeout());
|
|
}
|
|
if (other.hasLifeCycle()) {
|
|
mergeLifeCycle(other.getLifeCycle());
|
|
}
|
|
if (other.hasSupervisor()) {
|
|
mergeSupervisor(other.getSupervisor());
|
|
}
|
|
if (other.hasHotswapStack()) {
|
|
setHotswapStack(other.getHotswapStack());
|
|
}
|
|
if (other.hasReplicationStorage()) {
|
|
setReplicationStorage(other.getReplicationStorage());
|
|
}
|
|
if (other.hasReplicationStrategy()) {
|
|
setReplicationStrategy(other.getReplicationStrategy());
|
|
}
|
|
if (!other.messages_.isEmpty()) {
|
|
if (result.messages_.isEmpty()) {
|
|
result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
|
|
}
|
|
result.messages_.addAll(other.messages_);
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
|
|
if (hasUuid()) {
|
|
subBuilder.mergeFrom(getUuid());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setUuid(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setAddress(input.readString());
|
|
break;
|
|
}
|
|
case 26: {
|
|
setActorClassname(input.readString());
|
|
break;
|
|
}
|
|
case 34: {
|
|
setActorInstance(input.readBytes());
|
|
break;
|
|
}
|
|
case 42: {
|
|
setSerializerClassname(input.readString());
|
|
break;
|
|
}
|
|
case 48: {
|
|
setTimeout(input.readUInt64());
|
|
break;
|
|
}
|
|
case 56: {
|
|
setReceiveTimeout(input.readUInt64());
|
|
break;
|
|
}
|
|
case 66: {
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder();
|
|
if (hasLifeCycle()) {
|
|
subBuilder.mergeFrom(getLifeCycle());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setLifeCycle(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 74: {
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder();
|
|
if (hasSupervisor()) {
|
|
subBuilder.mergeFrom(getSupervisor());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setSupervisor(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 82: {
|
|
setHotswapStack(input.readBytes());
|
|
break;
|
|
}
|
|
case 88: {
|
|
int rawValue = input.readEnum();
|
|
akka.remote.protocol.RemoteProtocol.ReplicationStorageType value = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.valueOf(rawValue);
|
|
if (value == null) {
|
|
unknownFields.mergeVarintField(11, rawValue);
|
|
} else {
|
|
setReplicationStorage(value);
|
|
}
|
|
break;
|
|
}
|
|
case 96: {
|
|
int rawValue = input.readEnum();
|
|
akka.remote.protocol.RemoteProtocol.ReplicationStrategyType value = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.valueOf(rawValue);
|
|
if (value == null) {
|
|
unknownFields.mergeVarintField(12, rawValue);
|
|
} else {
|
|
setReplicationStrategy(value);
|
|
}
|
|
break;
|
|
}
|
|
case 106: {
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.newBuilder();
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
addMessages(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public boolean hasUuid() {
|
|
return result.hasUuid();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
|
|
return result.getUuid();
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasUuid = true;
|
|
result.uuid_ = value;
|
|
return this;
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
|
|
result.hasUuid = true;
|
|
result.uuid_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (result.hasUuid() &&
|
|
result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
|
|
result.uuid_ =
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.uuid_ = value;
|
|
}
|
|
result.hasUuid = true;
|
|
return this;
|
|
}
|
|
public Builder clearUuid() {
|
|
result.hasUuid = false;
|
|
result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// required string address = 2;
|
|
public boolean hasAddress() {
|
|
return result.hasAddress();
|
|
}
|
|
public java.lang.String getAddress() {
|
|
return result.getAddress();
|
|
}
|
|
public Builder setAddress(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasAddress = true;
|
|
result.address_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearAddress() {
|
|
result.hasAddress = false;
|
|
result.address_ = getDefaultInstance().getAddress();
|
|
return this;
|
|
}
|
|
|
|
// required string actorClassname = 3;
|
|
public boolean hasActorClassname() {
|
|
return result.hasActorClassname();
|
|
}
|
|
public java.lang.String getActorClassname() {
|
|
return result.getActorClassname();
|
|
}
|
|
public Builder setActorClassname(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasActorClassname = true;
|
|
result.actorClassname_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearActorClassname() {
|
|
result.hasActorClassname = false;
|
|
result.actorClassname_ = getDefaultInstance().getActorClassname();
|
|
return this;
|
|
}
|
|
|
|
// optional bytes actorInstance = 4;
|
|
public boolean hasActorInstance() {
|
|
return result.hasActorInstance();
|
|
}
|
|
public com.google.protobuf.ByteString getActorInstance() {
|
|
return result.getActorInstance();
|
|
}
|
|
public Builder setActorInstance(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasActorInstance = true;
|
|
result.actorInstance_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearActorInstance() {
|
|
result.hasActorInstance = false;
|
|
result.actorInstance_ = getDefaultInstance().getActorInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional string serializerClassname = 5;
|
|
public boolean hasSerializerClassname() {
|
|
return result.hasSerializerClassname();
|
|
}
|
|
public java.lang.String getSerializerClassname() {
|
|
return result.getSerializerClassname();
|
|
}
|
|
public Builder setSerializerClassname(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasSerializerClassname = true;
|
|
result.serializerClassname_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearSerializerClassname() {
|
|
result.hasSerializerClassname = false;
|
|
result.serializerClassname_ = getDefaultInstance().getSerializerClassname();
|
|
return this;
|
|
}
|
|
|
|
// optional uint64 timeout = 6;
|
|
public boolean hasTimeout() {
|
|
return result.hasTimeout();
|
|
}
|
|
public long getTimeout() {
|
|
return result.getTimeout();
|
|
}
|
|
public Builder setTimeout(long value) {
|
|
result.hasTimeout = true;
|
|
result.timeout_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearTimeout() {
|
|
result.hasTimeout = false;
|
|
result.timeout_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// optional uint64 receiveTimeout = 7;
|
|
public boolean hasReceiveTimeout() {
|
|
return result.hasReceiveTimeout();
|
|
}
|
|
public long getReceiveTimeout() {
|
|
return result.getReceiveTimeout();
|
|
}
|
|
public Builder setReceiveTimeout(long value) {
|
|
result.hasReceiveTimeout = true;
|
|
result.receiveTimeout_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearReceiveTimeout() {
|
|
result.hasReceiveTimeout = false;
|
|
result.receiveTimeout_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// optional .LifeCycleProtocol lifeCycle = 8;
|
|
public boolean hasLifeCycle() {
|
|
return result.hasLifeCycle();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getLifeCycle() {
|
|
return result.getLifeCycle();
|
|
}
|
|
public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasLifeCycle = true;
|
|
result.lifeCycle_ = value;
|
|
return this;
|
|
}
|
|
public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder builderForValue) {
|
|
result.hasLifeCycle = true;
|
|
result.lifeCycle_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol value) {
|
|
if (result.hasLifeCycle() &&
|
|
result.lifeCycle_ != akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) {
|
|
result.lifeCycle_ =
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder(result.lifeCycle_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.lifeCycle_ = value;
|
|
}
|
|
result.hasLifeCycle = true;
|
|
return this;
|
|
}
|
|
public Builder clearLifeCycle() {
|
|
result.hasLifeCycle = false;
|
|
result.lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional .RemoteActorRefProtocol supervisor = 9;
|
|
public boolean hasSupervisor() {
|
|
return result.hasSupervisor();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol getSupervisor() {
|
|
return result.getSupervisor();
|
|
}
|
|
public Builder setSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasSupervisor = true;
|
|
result.supervisor_ = value;
|
|
return this;
|
|
}
|
|
public Builder setSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder builderForValue) {
|
|
result.hasSupervisor = true;
|
|
result.supervisor_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeSupervisor(akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol value) {
|
|
if (result.hasSupervisor() &&
|
|
result.supervisor_ != akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance()) {
|
|
result.supervisor_ =
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.newBuilder(result.supervisor_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.supervisor_ = value;
|
|
}
|
|
result.hasSupervisor = true;
|
|
return this;
|
|
}
|
|
public Builder clearSupervisor() {
|
|
result.hasSupervisor = false;
|
|
result.supervisor_ = akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// optional bytes hotswapStack = 10;
|
|
public boolean hasHotswapStack() {
|
|
return result.hasHotswapStack();
|
|
}
|
|
public com.google.protobuf.ByteString getHotswapStack() {
|
|
return result.getHotswapStack();
|
|
}
|
|
public Builder setHotswapStack(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasHotswapStack = true;
|
|
result.hotswapStack_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearHotswapStack() {
|
|
result.hasHotswapStack = false;
|
|
result.hotswapStack_ = getDefaultInstance().getHotswapStack();
|
|
return this;
|
|
}
|
|
|
|
// optional .ReplicationStorageType replicationStorage = 11;
|
|
public boolean hasReplicationStorage() {
|
|
return result.hasReplicationStorage();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ReplicationStorageType getReplicationStorage() {
|
|
return result.getReplicationStorage();
|
|
}
|
|
public Builder setReplicationStorage(akka.remote.protocol.RemoteProtocol.ReplicationStorageType value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasReplicationStorage = true;
|
|
result.replicationStorage_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearReplicationStorage() {
|
|
result.hasReplicationStorage = false;
|
|
result.replicationStorage_ = akka.remote.protocol.RemoteProtocol.ReplicationStorageType.TRANSIENT;
|
|
return this;
|
|
}
|
|
|
|
// optional .ReplicationStrategyType replicationStrategy = 12;
|
|
public boolean hasReplicationStrategy() {
|
|
return result.hasReplicationStrategy();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ReplicationStrategyType getReplicationStrategy() {
|
|
return result.getReplicationStrategy();
|
|
}
|
|
public Builder setReplicationStrategy(akka.remote.protocol.RemoteProtocol.ReplicationStrategyType value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasReplicationStrategy = true;
|
|
result.replicationStrategy_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearReplicationStrategy() {
|
|
result.hasReplicationStrategy = false;
|
|
result.replicationStrategy_ = akka.remote.protocol.RemoteProtocol.ReplicationStrategyType.WRITE_THROUGH;
|
|
return this;
|
|
}
|
|
|
|
// repeated .RemoteMessageProtocol messages = 13;
|
|
public java.util.List<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> getMessagesList() {
|
|
return java.util.Collections.unmodifiableList(result.messages_);
|
|
}
|
|
public int getMessagesCount() {
|
|
return result.getMessagesCount();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol getMessages(int index) {
|
|
return result.getMessages(index);
|
|
}
|
|
public Builder setMessages(int index, akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.messages_.set(index, value);
|
|
return this;
|
|
}
|
|
public Builder setMessages(int index, akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
|
|
result.messages_.set(index, builderForValue.build());
|
|
return this;
|
|
}
|
|
public Builder addMessages(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
if (result.messages_.isEmpty()) {
|
|
result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
|
|
}
|
|
result.messages_.add(value);
|
|
return this;
|
|
}
|
|
public Builder addMessages(akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder builderForValue) {
|
|
if (result.messages_.isEmpty()) {
|
|
result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
|
|
}
|
|
result.messages_.add(builderForValue.build());
|
|
return this;
|
|
}
|
|
public Builder addAllMessages(
|
|
java.lang.Iterable<? extends akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol> values) {
|
|
if (result.messages_.isEmpty()) {
|
|
result.messages_ = new java.util.ArrayList<akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol>();
|
|
}
|
|
super.addAll(values, result.messages_);
|
|
return this;
|
|
}
|
|
public Builder clearMessages() {
|
|
result.messages_ = java.util.Collections.emptyList();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:SerializedActorRefProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new SerializedActorRefProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:SerializedActorRefProtocol)
|
|
}
|
|
|
|
public static final class SerializedTypedActorRefProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use SerializedTypedActorRefProtocol.newBuilder() to construct.
|
|
private SerializedTypedActorRefProtocol() {
|
|
initFields();
|
|
}
|
|
private SerializedTypedActorRefProtocol(boolean noInit) {}
|
|
|
|
private static final SerializedTypedActorRefProtocol defaultInstance;
|
|
public static SerializedTypedActorRefProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public SerializedTypedActorRefProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required .SerializedActorRefProtocol actorRef = 1;
|
|
public static final int ACTORREF_FIELD_NUMBER = 1;
|
|
private boolean hasActorRef;
|
|
private akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol actorRef_;
|
|
public boolean hasActorRef() { return hasActorRef; }
|
|
public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() { return actorRef_; }
|
|
|
|
// required string interfaceName = 2;
|
|
public static final int INTERFACENAME_FIELD_NUMBER = 2;
|
|
private boolean hasInterfaceName;
|
|
private java.lang.String interfaceName_ = "";
|
|
public boolean hasInterfaceName() { return hasInterfaceName; }
|
|
public java.lang.String getInterfaceName() { return interfaceName_; }
|
|
|
|
private void initFields() {
|
|
actorRef_ = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasActorRef) return false;
|
|
if (!hasInterfaceName) return false;
|
|
if (!getActorRef().isInitialized()) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasActorRef()) {
|
|
output.writeMessage(1, getActorRef());
|
|
}
|
|
if (hasInterfaceName()) {
|
|
output.writeString(2, getInterfaceName());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasActorRef()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(1, getActorRef());
|
|
}
|
|
if (hasInterfaceName()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(2, getInterfaceName());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
|
|
if (other.hasActorRef()) {
|
|
mergeActorRef(other.getActorRef());
|
|
}
|
|
if (other.hasInterfaceName()) {
|
|
setInterfaceName(other.getInterfaceName());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
|
|
if (hasActorRef()) {
|
|
subBuilder.mergeFrom(getActorRef());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setActorRef(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setInterfaceName(input.readString());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required .SerializedActorRefProtocol actorRef = 1;
|
|
public boolean hasActorRef() {
|
|
return result.hasActorRef();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
|
|
return result.getActorRef();
|
|
}
|
|
public Builder setActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasActorRef = true;
|
|
result.actorRef_ = value;
|
|
return this;
|
|
}
|
|
public Builder setActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
|
|
result.hasActorRef = true;
|
|
result.actorRef_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeActorRef(akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
|
|
if (result.hasActorRef() &&
|
|
result.actorRef_ != akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
|
|
result.actorRef_ =
|
|
akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder(result.actorRef_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.actorRef_ = value;
|
|
}
|
|
result.hasActorRef = true;
|
|
return this;
|
|
}
|
|
public Builder clearActorRef() {
|
|
result.hasActorRef = false;
|
|
result.actorRef_ = akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// required string interfaceName = 2;
|
|
public boolean hasInterfaceName() {
|
|
return result.hasInterfaceName();
|
|
}
|
|
public java.lang.String getInterfaceName() {
|
|
return result.getInterfaceName();
|
|
}
|
|
public Builder setInterfaceName(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasInterfaceName = true;
|
|
result.interfaceName_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearInterfaceName() {
|
|
result.hasInterfaceName = false;
|
|
result.interfaceName_ = getDefaultInstance().getInterfaceName();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:SerializedTypedActorRefProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new SerializedTypedActorRefProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:SerializedTypedActorRefProtocol)
|
|
}
|
|
|
|
public static final class MessageProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use MessageProtocol.newBuilder() to construct.
|
|
private MessageProtocol() {
|
|
initFields();
|
|
}
|
|
private MessageProtocol(boolean noInit) {}
|
|
|
|
private static final MessageProtocol defaultInstance;
|
|
public static MessageProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public MessageProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_MessageProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required bytes message = 1;
|
|
public static final int MESSAGE_FIELD_NUMBER = 1;
|
|
private boolean hasMessage;
|
|
private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasMessage() { return hasMessage; }
|
|
public com.google.protobuf.ByteString getMessage() { return message_; }
|
|
|
|
// optional bytes messageManifest = 2;
|
|
public static final int MESSAGEMANIFEST_FIELD_NUMBER = 2;
|
|
private boolean hasMessageManifest;
|
|
private com.google.protobuf.ByteString messageManifest_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasMessageManifest() { return hasMessageManifest; }
|
|
public com.google.protobuf.ByteString getMessageManifest() { return messageManifest_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasMessage) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasMessage()) {
|
|
output.writeBytes(1, getMessage());
|
|
}
|
|
if (hasMessageManifest()) {
|
|
output.writeBytes(2, getMessageManifest());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasMessage()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(1, getMessage());
|
|
}
|
|
if (hasMessageManifest()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(2, getMessageManifest());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MessageProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.MessageProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.MessageProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.MessageProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.MessageProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.MessageProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.MessageProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.MessageProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.MessageProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.MessageProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.MessageProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.MessageProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.MessageProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.MessageProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.MessageProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
|
|
if (other.hasMessage()) {
|
|
setMessage(other.getMessage());
|
|
}
|
|
if (other.hasMessageManifest()) {
|
|
setMessageManifest(other.getMessageManifest());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setMessage(input.readBytes());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setMessageManifest(input.readBytes());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required bytes message = 1;
|
|
public boolean hasMessage() {
|
|
return result.hasMessage();
|
|
}
|
|
public com.google.protobuf.ByteString getMessage() {
|
|
return result.getMessage();
|
|
}
|
|
public Builder setMessage(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasMessage = true;
|
|
result.message_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearMessage() {
|
|
result.hasMessage = false;
|
|
result.message_ = getDefaultInstance().getMessage();
|
|
return this;
|
|
}
|
|
|
|
// optional bytes messageManifest = 2;
|
|
public boolean hasMessageManifest() {
|
|
return result.hasMessageManifest();
|
|
}
|
|
public com.google.protobuf.ByteString getMessageManifest() {
|
|
return result.getMessageManifest();
|
|
}
|
|
public Builder setMessageManifest(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasMessageManifest = true;
|
|
result.messageManifest_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearMessageManifest() {
|
|
result.hasMessageManifest = false;
|
|
result.messageManifest_ = getDefaultInstance().getMessageManifest();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:MessageProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new MessageProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:MessageProtocol)
|
|
}
|
|
|
|
public static final class ActorInfoProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use ActorInfoProtocol.newBuilder() to construct.
|
|
private ActorInfoProtocol() {
|
|
initFields();
|
|
}
|
|
private ActorInfoProtocol(boolean noInit) {}
|
|
|
|
private static final ActorInfoProtocol defaultInstance;
|
|
public static ActorInfoProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public ActorInfoProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_ActorInfoProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_ActorInfoProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public static final int UUID_FIELD_NUMBER = 1;
|
|
private boolean hasUuid;
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol uuid_;
|
|
public boolean hasUuid() { return hasUuid; }
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() { return uuid_; }
|
|
|
|
// required uint64 timeout = 2;
|
|
public static final int TIMEOUT_FIELD_NUMBER = 2;
|
|
private boolean hasTimeout;
|
|
private long timeout_ = 0L;
|
|
public boolean hasTimeout() { return hasTimeout; }
|
|
public long getTimeout() { return timeout_; }
|
|
|
|
// optional string address = 3;
|
|
public static final int ADDRESS_FIELD_NUMBER = 3;
|
|
private boolean hasAddress;
|
|
private java.lang.String address_ = "";
|
|
public boolean hasAddress() { return hasAddress; }
|
|
public java.lang.String getAddress() { return address_; }
|
|
|
|
private void initFields() {
|
|
uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasUuid) return false;
|
|
if (!hasTimeout) return false;
|
|
if (!getUuid().isInitialized()) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasUuid()) {
|
|
output.writeMessage(1, getUuid());
|
|
}
|
|
if (hasTimeout()) {
|
|
output.writeUInt64(2, getTimeout());
|
|
}
|
|
if (hasAddress()) {
|
|
output.writeString(3, getAddress());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasUuid()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeMessageSize(1, getUuid());
|
|
}
|
|
if (hasTimeout()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(2, getTimeout());
|
|
}
|
|
if (hasAddress()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(3, getAddress());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ActorInfoProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.ActorInfoProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.ActorInfoProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.ActorInfoProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.ActorInfoProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.ActorInfoProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.ActorInfoProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.ActorInfoProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.ActorInfoProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.ActorInfoProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.getDefaultInstance()) return this;
|
|
if (other.hasUuid()) {
|
|
mergeUuid(other.getUuid());
|
|
}
|
|
if (other.hasTimeout()) {
|
|
setTimeout(other.getTimeout());
|
|
}
|
|
if (other.hasAddress()) {
|
|
setAddress(other.getAddress());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder subBuilder = akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder();
|
|
if (hasUuid()) {
|
|
subBuilder.mergeFrom(getUuid());
|
|
}
|
|
input.readMessage(subBuilder, extensionRegistry);
|
|
setUuid(subBuilder.buildPartial());
|
|
break;
|
|
}
|
|
case 16: {
|
|
setTimeout(input.readUInt64());
|
|
break;
|
|
}
|
|
case 26: {
|
|
setAddress(input.readString());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required .UuidProtocol uuid = 1;
|
|
public boolean hasUuid() {
|
|
return result.hasUuid();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getUuid() {
|
|
return result.getUuid();
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasUuid = true;
|
|
result.uuid_ = value;
|
|
return this;
|
|
}
|
|
public Builder setUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder builderForValue) {
|
|
result.hasUuid = true;
|
|
result.uuid_ = builderForValue.build();
|
|
return this;
|
|
}
|
|
public Builder mergeUuid(akka.remote.protocol.RemoteProtocol.UuidProtocol value) {
|
|
if (result.hasUuid() &&
|
|
result.uuid_ != akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) {
|
|
result.uuid_ =
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder(result.uuid_).mergeFrom(value).buildPartial();
|
|
} else {
|
|
result.uuid_ = value;
|
|
}
|
|
result.hasUuid = true;
|
|
return this;
|
|
}
|
|
public Builder clearUuid() {
|
|
result.hasUuid = false;
|
|
result.uuid_ = akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
return this;
|
|
}
|
|
|
|
// required uint64 timeout = 2;
|
|
public boolean hasTimeout() {
|
|
return result.hasTimeout();
|
|
}
|
|
public long getTimeout() {
|
|
return result.getTimeout();
|
|
}
|
|
public Builder setTimeout(long value) {
|
|
result.hasTimeout = true;
|
|
result.timeout_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearTimeout() {
|
|
result.hasTimeout = false;
|
|
result.timeout_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// optional string address = 3;
|
|
public boolean hasAddress() {
|
|
return result.hasAddress();
|
|
}
|
|
public java.lang.String getAddress() {
|
|
return result.getAddress();
|
|
}
|
|
public Builder setAddress(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasAddress = true;
|
|
result.address_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearAddress() {
|
|
result.hasAddress = false;
|
|
result.address_ = getDefaultInstance().getAddress();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:ActorInfoProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new ActorInfoProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:ActorInfoProtocol)
|
|
}
|
|
|
|
public static final class UuidProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use UuidProtocol.newBuilder() to construct.
|
|
private UuidProtocol() {
|
|
initFields();
|
|
}
|
|
private UuidProtocol(boolean noInit) {}
|
|
|
|
private static final UuidProtocol defaultInstance;
|
|
public static UuidProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public UuidProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_UuidProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_UuidProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required uint64 high = 1;
|
|
public static final int HIGH_FIELD_NUMBER = 1;
|
|
private boolean hasHigh;
|
|
private long high_ = 0L;
|
|
public boolean hasHigh() { return hasHigh; }
|
|
public long getHigh() { return high_; }
|
|
|
|
// required uint64 low = 2;
|
|
public static final int LOW_FIELD_NUMBER = 2;
|
|
private boolean hasLow;
|
|
private long low_ = 0L;
|
|
public boolean hasLow() { return hasLow; }
|
|
public long getLow() { return low_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasHigh) return false;
|
|
if (!hasLow) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasHigh()) {
|
|
output.writeUInt64(1, getHigh());
|
|
}
|
|
if (hasLow()) {
|
|
output.writeUInt64(2, getLow());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasHigh()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(1, getHigh());
|
|
}
|
|
if (hasLow()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt64Size(2, getLow());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.UuidProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.UuidProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.UuidProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.UuidProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.UuidProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.UuidProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.UuidProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.UuidProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.UuidProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.UuidProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.UuidProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.UuidProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.UuidProtocol.getDefaultInstance()) return this;
|
|
if (other.hasHigh()) {
|
|
setHigh(other.getHigh());
|
|
}
|
|
if (other.hasLow()) {
|
|
setLow(other.getLow());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 8: {
|
|
setHigh(input.readUInt64());
|
|
break;
|
|
}
|
|
case 16: {
|
|
setLow(input.readUInt64());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required uint64 high = 1;
|
|
public boolean hasHigh() {
|
|
return result.hasHigh();
|
|
}
|
|
public long getHigh() {
|
|
return result.getHigh();
|
|
}
|
|
public Builder setHigh(long value) {
|
|
result.hasHigh = true;
|
|
result.high_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearHigh() {
|
|
result.hasHigh = false;
|
|
result.high_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// required uint64 low = 2;
|
|
public boolean hasLow() {
|
|
return result.hasLow();
|
|
}
|
|
public long getLow() {
|
|
return result.getLow();
|
|
}
|
|
public Builder setLow(long value) {
|
|
result.hasLow = true;
|
|
result.low_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearLow() {
|
|
result.hasLow = false;
|
|
result.low_ = 0L;
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:UuidProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new UuidProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:UuidProtocol)
|
|
}
|
|
|
|
public static final class MetadataEntryProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use MetadataEntryProtocol.newBuilder() to construct.
|
|
private MetadataEntryProtocol() {
|
|
initFields();
|
|
}
|
|
private MetadataEntryProtocol(boolean noInit) {}
|
|
|
|
private static final MetadataEntryProtocol defaultInstance;
|
|
public static MetadataEntryProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public MetadataEntryProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required string key = 1;
|
|
public static final int KEY_FIELD_NUMBER = 1;
|
|
private boolean hasKey;
|
|
private java.lang.String key_ = "";
|
|
public boolean hasKey() { return hasKey; }
|
|
public java.lang.String getKey() { return key_; }
|
|
|
|
// required bytes value = 2;
|
|
public static final int VALUE_FIELD_NUMBER = 2;
|
|
private boolean hasValue;
|
|
private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY;
|
|
public boolean hasValue() { return hasValue; }
|
|
public com.google.protobuf.ByteString getValue() { return value_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasKey) return false;
|
|
if (!hasValue) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasKey()) {
|
|
output.writeString(1, getKey());
|
|
}
|
|
if (hasValue()) {
|
|
output.writeBytes(2, getValue());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasKey()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(1, getKey());
|
|
}
|
|
if (hasValue()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeBytesSize(2, getValue());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
|
|
if (other.hasKey()) {
|
|
setKey(other.getKey());
|
|
}
|
|
if (other.hasValue()) {
|
|
setValue(other.getValue());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setKey(input.readString());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setValue(input.readBytes());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required string key = 1;
|
|
public boolean hasKey() {
|
|
return result.hasKey();
|
|
}
|
|
public java.lang.String getKey() {
|
|
return result.getKey();
|
|
}
|
|
public Builder setKey(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasKey = true;
|
|
result.key_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearKey() {
|
|
result.hasKey = false;
|
|
result.key_ = getDefaultInstance().getKey();
|
|
return this;
|
|
}
|
|
|
|
// required bytes value = 2;
|
|
public boolean hasValue() {
|
|
return result.hasValue();
|
|
}
|
|
public com.google.protobuf.ByteString getValue() {
|
|
return result.getValue();
|
|
}
|
|
public Builder setValue(com.google.protobuf.ByteString value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasValue = true;
|
|
result.value_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearValue() {
|
|
result.hasValue = false;
|
|
result.value_ = getDefaultInstance().getValue();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:MetadataEntryProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new MetadataEntryProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:MetadataEntryProtocol)
|
|
}
|
|
|
|
public static final class LifeCycleProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use LifeCycleProtocol.newBuilder() to construct.
|
|
private LifeCycleProtocol() {
|
|
initFields();
|
|
}
|
|
private LifeCycleProtocol(boolean noInit) {}
|
|
|
|
private static final LifeCycleProtocol defaultInstance;
|
|
public static LifeCycleProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public LifeCycleProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_LifeCycleProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_LifeCycleProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required .LifeCycleType lifeCycle = 1;
|
|
public static final int LIFECYCLE_FIELD_NUMBER = 1;
|
|
private boolean hasLifeCycle;
|
|
private akka.remote.protocol.RemoteProtocol.LifeCycleType lifeCycle_;
|
|
public boolean hasLifeCycle() { return hasLifeCycle; }
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleType getLifeCycle() { return lifeCycle_; }
|
|
|
|
private void initFields() {
|
|
lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleType.PERMANENT;
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasLifeCycle) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasLifeCycle()) {
|
|
output.writeEnum(1, getLifeCycle().getNumber());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasLifeCycle()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeEnumSize(1, getLifeCycle().getNumber());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.LifeCycleProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.LifeCycleProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.LifeCycleProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.LifeCycleProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.LifeCycleProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.LifeCycleProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.LifeCycleProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.LifeCycleProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.getDefaultInstance()) return this;
|
|
if (other.hasLifeCycle()) {
|
|
setLifeCycle(other.getLifeCycle());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 8: {
|
|
int rawValue = input.readEnum();
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleType value = akka.remote.protocol.RemoteProtocol.LifeCycleType.valueOf(rawValue);
|
|
if (value == null) {
|
|
unknownFields.mergeVarintField(1, rawValue);
|
|
} else {
|
|
setLifeCycle(value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required .LifeCycleType lifeCycle = 1;
|
|
public boolean hasLifeCycle() {
|
|
return result.hasLifeCycle();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.LifeCycleType getLifeCycle() {
|
|
return result.getLifeCycle();
|
|
}
|
|
public Builder setLifeCycle(akka.remote.protocol.RemoteProtocol.LifeCycleType value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasLifeCycle = true;
|
|
result.lifeCycle_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearLifeCycle() {
|
|
result.hasLifeCycle = false;
|
|
result.lifeCycle_ = akka.remote.protocol.RemoteProtocol.LifeCycleType.PERMANENT;
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:LifeCycleProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new LifeCycleProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:LifeCycleProtocol)
|
|
}
|
|
|
|
public static final class AddressProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use AddressProtocol.newBuilder() to construct.
|
|
private AddressProtocol() {
|
|
initFields();
|
|
}
|
|
private AddressProtocol(boolean noInit) {}
|
|
|
|
private static final AddressProtocol defaultInstance;
|
|
public static AddressProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public AddressProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_AddressProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required string hostname = 1;
|
|
public static final int HOSTNAME_FIELD_NUMBER = 1;
|
|
private boolean hasHostname;
|
|
private java.lang.String hostname_ = "";
|
|
public boolean hasHostname() { return hasHostname; }
|
|
public java.lang.String getHostname() { return hostname_; }
|
|
|
|
// required uint32 port = 2;
|
|
public static final int PORT_FIELD_NUMBER = 2;
|
|
private boolean hasPort;
|
|
private int port_ = 0;
|
|
public boolean hasPort() { return hasPort; }
|
|
public int getPort() { return port_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasHostname) return false;
|
|
if (!hasPort) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasHostname()) {
|
|
output.writeString(1, getHostname());
|
|
}
|
|
if (hasPort()) {
|
|
output.writeUInt32(2, getPort());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasHostname()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(1, getHostname());
|
|
}
|
|
if (hasPort()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeUInt32Size(2, getPort());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.AddressProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.AddressProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.AddressProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.AddressProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.AddressProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.AddressProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.AddressProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.AddressProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.AddressProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.AddressProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.AddressProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.AddressProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.AddressProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.AddressProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.AddressProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.AddressProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
|
|
if (other.hasHostname()) {
|
|
setHostname(other.getHostname());
|
|
}
|
|
if (other.hasPort()) {
|
|
setPort(other.getPort());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setHostname(input.readString());
|
|
break;
|
|
}
|
|
case 16: {
|
|
setPort(input.readUInt32());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required string hostname = 1;
|
|
public boolean hasHostname() {
|
|
return result.hasHostname();
|
|
}
|
|
public java.lang.String getHostname() {
|
|
return result.getHostname();
|
|
}
|
|
public Builder setHostname(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasHostname = true;
|
|
result.hostname_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearHostname() {
|
|
result.hasHostname = false;
|
|
result.hostname_ = getDefaultInstance().getHostname();
|
|
return this;
|
|
}
|
|
|
|
// required uint32 port = 2;
|
|
public boolean hasPort() {
|
|
return result.hasPort();
|
|
}
|
|
public int getPort() {
|
|
return result.getPort();
|
|
}
|
|
public Builder setPort(int value) {
|
|
result.hasPort = true;
|
|
result.port_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearPort() {
|
|
result.hasPort = false;
|
|
result.port_ = 0;
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:AddressProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new AddressProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:AddressProtocol)
|
|
}
|
|
|
|
public static final class ExceptionProtocol extends
|
|
com.google.protobuf.GeneratedMessage {
|
|
// Use ExceptionProtocol.newBuilder() to construct.
|
|
private ExceptionProtocol() {
|
|
initFields();
|
|
}
|
|
private ExceptionProtocol(boolean noInit) {}
|
|
|
|
private static final ExceptionProtocol defaultInstance;
|
|
public static ExceptionProtocol getDefaultInstance() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public ExceptionProtocol getDefaultInstanceForType() {
|
|
return defaultInstance;
|
|
}
|
|
|
|
public static final com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptor() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
|
|
}
|
|
|
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internalGetFieldAccessorTable() {
|
|
return akka.remote.protocol.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
|
|
}
|
|
|
|
// required string classname = 1;
|
|
public static final int CLASSNAME_FIELD_NUMBER = 1;
|
|
private boolean hasClassname;
|
|
private java.lang.String classname_ = "";
|
|
public boolean hasClassname() { return hasClassname; }
|
|
public java.lang.String getClassname() { return classname_; }
|
|
|
|
// required string message = 2;
|
|
public static final int MESSAGE_FIELD_NUMBER = 2;
|
|
private boolean hasMessage;
|
|
private java.lang.String message_ = "";
|
|
public boolean hasMessage() { return hasMessage; }
|
|
public java.lang.String getMessage() { return message_; }
|
|
|
|
private void initFields() {
|
|
}
|
|
public final boolean isInitialized() {
|
|
if (!hasClassname) return false;
|
|
if (!hasMessage) return false;
|
|
return true;
|
|
}
|
|
|
|
public void writeTo(com.google.protobuf.CodedOutputStream output)
|
|
throws java.io.IOException {
|
|
getSerializedSize();
|
|
if (hasClassname()) {
|
|
output.writeString(1, getClassname());
|
|
}
|
|
if (hasMessage()) {
|
|
output.writeString(2, getMessage());
|
|
}
|
|
getUnknownFields().writeTo(output);
|
|
}
|
|
|
|
private int memoizedSerializedSize = -1;
|
|
public int getSerializedSize() {
|
|
int size = memoizedSerializedSize;
|
|
if (size != -1) return size;
|
|
|
|
size = 0;
|
|
if (hasClassname()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(1, getClassname());
|
|
}
|
|
if (hasMessage()) {
|
|
size += com.google.protobuf.CodedOutputStream
|
|
.computeStringSize(2, getMessage());
|
|
}
|
|
size += getUnknownFields().getSerializedSize();
|
|
memoizedSerializedSize = size;
|
|
return size;
|
|
}
|
|
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
com.google.protobuf.ByteString data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
com.google.protobuf.ByteString data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(byte[] data)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
byte[] data,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
return newBuilder().mergeFrom(data, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(java.io.InputStream input)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseDelimitedFrom(
|
|
java.io.InputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
Builder builder = newBuilder();
|
|
if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
|
|
return builder.buildParsed();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input).buildParsed();
|
|
}
|
|
public static akka.remote.protocol.RemoteProtocol.ExceptionProtocol parseFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
return newBuilder().mergeFrom(input, extensionRegistry)
|
|
.buildParsed();
|
|
}
|
|
|
|
public static Builder newBuilder() { return Builder.create(); }
|
|
public Builder newBuilderForType() { return newBuilder(); }
|
|
public static Builder newBuilder(akka.remote.protocol.RemoteProtocol.ExceptionProtocol prototype) {
|
|
return newBuilder().mergeFrom(prototype);
|
|
}
|
|
public Builder toBuilder() { return newBuilder(this); }
|
|
|
|
public static final class Builder extends
|
|
com.google.protobuf.GeneratedMessage.Builder<Builder> {
|
|
private akka.remote.protocol.RemoteProtocol.ExceptionProtocol result;
|
|
|
|
// Construct using akka.remote.protocol.RemoteProtocol.ExceptionProtocol.newBuilder()
|
|
private Builder() {}
|
|
|
|
private static Builder create() {
|
|
Builder builder = new Builder();
|
|
builder.result = new akka.remote.protocol.RemoteProtocol.ExceptionProtocol();
|
|
return builder;
|
|
}
|
|
|
|
protected akka.remote.protocol.RemoteProtocol.ExceptionProtocol internalGetResult() {
|
|
return result;
|
|
}
|
|
|
|
public Builder clear() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"Cannot call clear() after build().");
|
|
}
|
|
result = new akka.remote.protocol.RemoteProtocol.ExceptionProtocol();
|
|
return this;
|
|
}
|
|
|
|
public Builder clone() {
|
|
return create().mergeFrom(result);
|
|
}
|
|
|
|
public com.google.protobuf.Descriptors.Descriptor
|
|
getDescriptorForType() {
|
|
return akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDescriptor();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.ExceptionProtocol getDefaultInstanceForType() {
|
|
return akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
|
|
}
|
|
|
|
public boolean isInitialized() {
|
|
return result.isInitialized();
|
|
}
|
|
public akka.remote.protocol.RemoteProtocol.ExceptionProtocol build() {
|
|
if (result != null && !isInitialized()) {
|
|
throw newUninitializedMessageException(result);
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
private akka.remote.protocol.RemoteProtocol.ExceptionProtocol buildParsed()
|
|
throws com.google.protobuf.InvalidProtocolBufferException {
|
|
if (!isInitialized()) {
|
|
throw newUninitializedMessageException(
|
|
result).asInvalidProtocolBufferException();
|
|
}
|
|
return buildPartial();
|
|
}
|
|
|
|
public akka.remote.protocol.RemoteProtocol.ExceptionProtocol buildPartial() {
|
|
if (result == null) {
|
|
throw new IllegalStateException(
|
|
"build() has already been called on this Builder.");
|
|
}
|
|
akka.remote.protocol.RemoteProtocol.ExceptionProtocol returnMe = result;
|
|
result = null;
|
|
return returnMe;
|
|
}
|
|
|
|
public Builder mergeFrom(com.google.protobuf.Message other) {
|
|
if (other instanceof akka.remote.protocol.RemoteProtocol.ExceptionProtocol) {
|
|
return mergeFrom((akka.remote.protocol.RemoteProtocol.ExceptionProtocol)other);
|
|
} else {
|
|
super.mergeFrom(other);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
public Builder mergeFrom(akka.remote.protocol.RemoteProtocol.ExceptionProtocol other) {
|
|
if (other == akka.remote.protocol.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) return this;
|
|
if (other.hasClassname()) {
|
|
setClassname(other.getClassname());
|
|
}
|
|
if (other.hasMessage()) {
|
|
setMessage(other.getMessage());
|
|
}
|
|
this.mergeUnknownFields(other.getUnknownFields());
|
|
return this;
|
|
}
|
|
|
|
public Builder mergeFrom(
|
|
com.google.protobuf.CodedInputStream input,
|
|
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
|
|
throws java.io.IOException {
|
|
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
|
|
com.google.protobuf.UnknownFieldSet.newBuilder(
|
|
this.getUnknownFields());
|
|
while (true) {
|
|
int tag = input.readTag();
|
|
switch (tag) {
|
|
case 0:
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
default: {
|
|
if (!parseUnknownField(input, unknownFields,
|
|
extensionRegistry, tag)) {
|
|
this.setUnknownFields(unknownFields.build());
|
|
return this;
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
setClassname(input.readString());
|
|
break;
|
|
}
|
|
case 18: {
|
|
setMessage(input.readString());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// required string classname = 1;
|
|
public boolean hasClassname() {
|
|
return result.hasClassname();
|
|
}
|
|
public java.lang.String getClassname() {
|
|
return result.getClassname();
|
|
}
|
|
public Builder setClassname(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasClassname = true;
|
|
result.classname_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearClassname() {
|
|
result.hasClassname = false;
|
|
result.classname_ = getDefaultInstance().getClassname();
|
|
return this;
|
|
}
|
|
|
|
// required string message = 2;
|
|
public boolean hasMessage() {
|
|
return result.hasMessage();
|
|
}
|
|
public java.lang.String getMessage() {
|
|
return result.getMessage();
|
|
}
|
|
public Builder setMessage(java.lang.String value) {
|
|
if (value == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
result.hasMessage = true;
|
|
result.message_ = value;
|
|
return this;
|
|
}
|
|
public Builder clearMessage() {
|
|
result.hasMessage = false;
|
|
result.message_ = getDefaultInstance().getMessage();
|
|
return this;
|
|
}
|
|
|
|
// @@protoc_insertion_point(builder_scope:ExceptionProtocol)
|
|
}
|
|
|
|
static {
|
|
defaultInstance = new ExceptionProtocol(true);
|
|
akka.remote.protocol.RemoteProtocol.internalForceInit();
|
|
defaultInstance.initFields();
|
|
}
|
|
|
|
// @@protoc_insertion_point(class_scope:ExceptionProtocol)
|
|
}
|
|
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_AkkaRemoteProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_AkkaRemoteProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_RemoteMessageProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_RemoteMessageProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_RemoteControlProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_RemoteControlProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_RemoteActorRefProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_RemoteActorRefProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_SerializedActorRefProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_SerializedActorRefProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_SerializedTypedActorRefProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_MessageProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_MessageProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_ActorInfoProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_ActorInfoProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_UuidProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_UuidProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_MetadataEntryProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_MetadataEntryProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_LifeCycleProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_LifeCycleProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_AddressProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_AddressProtocol_fieldAccessorTable;
|
|
private static com.google.protobuf.Descriptors.Descriptor
|
|
internal_static_ExceptionProtocol_descriptor;
|
|
private static
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable
|
|
internal_static_ExceptionProtocol_fieldAccessorTable;
|
|
|
|
public static com.google.protobuf.Descriptors.FileDescriptor
|
|
getDescriptor() {
|
|
return descriptor;
|
|
}
|
|
private static com.google.protobuf.Descriptors.FileDescriptor
|
|
descriptor;
|
|
static {
|
|
java.lang.String[] descriptorData = {
|
|
"\n\024RemoteProtocol.proto\"j\n\022AkkaRemoteProt" +
|
|
"ocol\022\'\n\007message\030\001 \001(\0132\026.RemoteMessagePro" +
|
|
"tocol\022+\n\013instruction\030\002 \001(\0132\026.RemoteContr" +
|
|
"olProtocol\"\257\002\n\025RemoteMessageProtocol\022\033\n\004" +
|
|
"uuid\030\001 \002(\0132\r.UuidProtocol\022%\n\tactorInfo\030\002" +
|
|
" \002(\0132\022.ActorInfoProtocol\022\016\n\006oneWay\030\003 \002(\010" +
|
|
"\022!\n\007message\030\004 \001(\0132\020.MessageProtocol\022%\n\te" +
|
|
"xception\030\005 \001(\0132\022.ExceptionProtocol\022%\n\016su" +
|
|
"pervisorUuid\030\006 \001(\0132\r.UuidProtocol\022\'\n\006sen" +
|
|
"der\030\007 \001(\0132\027.RemoteActorRefProtocol\022(\n\010me",
|
|
"tadata\030\010 \003(\0132\026.MetadataEntryProtocol\"J\n\025" +
|
|
"RemoteControlProtocol\022\016\n\006cookie\030\001 \001(\t\022!\n" +
|
|
"\013commandType\030\002 \002(\0162\014.CommandType\"U\n\026Remo" +
|
|
"teActorRefProtocol\022\017\n\007address\030\001 \002(\t\022\031\n\021i" +
|
|
"netSocketAddress\030\002 \002(\014\022\017\n\007timeout\030\003 \001(\004\"" +
|
|
"\277\003\n\032SerializedActorRefProtocol\022\033\n\004uuid\030\001" +
|
|
" \002(\0132\r.UuidProtocol\022\017\n\007address\030\002 \002(\t\022\026\n\016" +
|
|
"actorClassname\030\003 \002(\t\022\025\n\ractorInstance\030\004 " +
|
|
"\001(\014\022\033\n\023serializerClassname\030\005 \001(\t\022\017\n\007time" +
|
|
"out\030\006 \001(\004\022\026\n\016receiveTimeout\030\007 \001(\004\022%\n\tlif",
|
|
"eCycle\030\010 \001(\0132\022.LifeCycleProtocol\022+\n\nsupe" +
|
|
"rvisor\030\t \001(\0132\027.RemoteActorRefProtocol\022\024\n" +
|
|
"\014hotswapStack\030\n \001(\014\0223\n\022replicationStorag" +
|
|
"e\030\013 \001(\0162\027.ReplicationStorageType\0225\n\023repl" +
|
|
"icationStrategy\030\014 \001(\0162\030.ReplicationStrat" +
|
|
"egyType\022(\n\010messages\030\r \003(\0132\026.RemoteMessag" +
|
|
"eProtocol\"g\n\037SerializedTypedActorRefProt" +
|
|
"ocol\022-\n\010actorRef\030\001 \002(\0132\033.SerializedActor" +
|
|
"RefProtocol\022\025\n\rinterfaceName\030\002 \002(\t\";\n\017Me" +
|
|
"ssageProtocol\022\017\n\007message\030\001 \002(\014\022\027\n\017messag",
|
|
"eManifest\030\002 \001(\014\"R\n\021ActorInfoProtocol\022\033\n\004" +
|
|
"uuid\030\001 \002(\0132\r.UuidProtocol\022\017\n\007timeout\030\002 \002" +
|
|
"(\004\022\017\n\007address\030\003 \001(\t\")\n\014UuidProtocol\022\014\n\004h" +
|
|
"igh\030\001 \002(\004\022\013\n\003low\030\002 \002(\004\"3\n\025MetadataEntryP" +
|
|
"rotocol\022\013\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\014\"6\n\021L" +
|
|
"ifeCycleProtocol\022!\n\tlifeCycle\030\001 \002(\0162\016.Li" +
|
|
"feCycleType\"1\n\017AddressProtocol\022\020\n\010hostna" +
|
|
"me\030\001 \002(\t\022\014\n\004port\030\002 \002(\r\"7\n\021ExceptionProto" +
|
|
"col\022\021\n\tclassname\030\001 \002(\t\022\017\n\007message\030\002 \002(\t*" +
|
|
"(\n\013CommandType\022\013\n\007CONNECT\020\001\022\014\n\010SHUTDOWN\020",
|
|
"\002*K\n\026ReplicationStorageType\022\r\n\tTRANSIENT" +
|
|
"\020\001\022\023\n\017TRANSACTION_LOG\020\002\022\r\n\tDATA_GRID\020\003*>" +
|
|
"\n\027ReplicationStrategyType\022\021\n\rWRITE_THROU" +
|
|
"GH\020\001\022\020\n\014WRITE_BEHIND\020\002*]\n\027SerializationS" +
|
|
"chemeType\022\010\n\004JAVA\020\001\022\013\n\007SBINARY\020\002\022\016\n\nSCAL" +
|
|
"A_JSON\020\003\022\r\n\tJAVA_JSON\020\004\022\014\n\010PROTOBUF\020\005*-\n" +
|
|
"\rLifeCycleType\022\r\n\tPERMANENT\020\001\022\r\n\tTEMPORA" +
|
|
"RY\020\002B\030\n\024akka.remote.protocolH\001"
|
|
};
|
|
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
|
|
new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
|
|
public com.google.protobuf.ExtensionRegistry assignDescriptors(
|
|
com.google.protobuf.Descriptors.FileDescriptor root) {
|
|
descriptor = root;
|
|
internal_static_AkkaRemoteProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(0);
|
|
internal_static_AkkaRemoteProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_AkkaRemoteProtocol_descriptor,
|
|
new java.lang.String[] { "Message", "Instruction", },
|
|
akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.AkkaRemoteProtocol.Builder.class);
|
|
internal_static_RemoteMessageProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(1);
|
|
internal_static_RemoteMessageProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_RemoteMessageProtocol_descriptor,
|
|
new java.lang.String[] { "Uuid", "ActorInfo", "OneWay", "Message", "Exception", "SupervisorUuid", "Sender", "Metadata", },
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.RemoteMessageProtocol.Builder.class);
|
|
internal_static_RemoteControlProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(2);
|
|
internal_static_RemoteControlProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_RemoteControlProtocol_descriptor,
|
|
new java.lang.String[] { "Cookie", "CommandType", },
|
|
akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.RemoteControlProtocol.Builder.class);
|
|
internal_static_RemoteActorRefProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(3);
|
|
internal_static_RemoteActorRefProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_RemoteActorRefProtocol_descriptor,
|
|
new java.lang.String[] { "Address", "InetSocketAddress", "Timeout", },
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
|
|
internal_static_SerializedActorRefProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(4);
|
|
internal_static_SerializedActorRefProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_SerializedActorRefProtocol_descriptor,
|
|
new java.lang.String[] { "Uuid", "Address", "ActorClassname", "ActorInstance", "SerializerClassname", "Timeout", "ReceiveTimeout", "LifeCycle", "Supervisor", "HotswapStack", "ReplicationStorage", "ReplicationStrategy", "Messages", },
|
|
akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
|
|
internal_static_SerializedTypedActorRefProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(5);
|
|
internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_SerializedTypedActorRefProtocol_descriptor,
|
|
new java.lang.String[] { "ActorRef", "InterfaceName", },
|
|
akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
|
|
internal_static_MessageProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(6);
|
|
internal_static_MessageProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_MessageProtocol_descriptor,
|
|
new java.lang.String[] { "Message", "MessageManifest", },
|
|
akka.remote.protocol.RemoteProtocol.MessageProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder.class);
|
|
internal_static_ActorInfoProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(7);
|
|
internal_static_ActorInfoProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_ActorInfoProtocol_descriptor,
|
|
new java.lang.String[] { "Uuid", "Timeout", "Address", },
|
|
akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder.class);
|
|
internal_static_UuidProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(8);
|
|
internal_static_UuidProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_UuidProtocol_descriptor,
|
|
new java.lang.String[] { "High", "Low", },
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder.class);
|
|
internal_static_MetadataEntryProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(9);
|
|
internal_static_MetadataEntryProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_MetadataEntryProtocol_descriptor,
|
|
new java.lang.String[] { "Key", "Value", },
|
|
akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder.class);
|
|
internal_static_LifeCycleProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(10);
|
|
internal_static_LifeCycleProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_LifeCycleProtocol_descriptor,
|
|
new java.lang.String[] { "LifeCycle", },
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder.class);
|
|
internal_static_AddressProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(11);
|
|
internal_static_AddressProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_AddressProtocol_descriptor,
|
|
new java.lang.String[] { "Hostname", "Port", },
|
|
akka.remote.protocol.RemoteProtocol.AddressProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.AddressProtocol.Builder.class);
|
|
internal_static_ExceptionProtocol_descriptor =
|
|
getDescriptor().getMessageTypes().get(12);
|
|
internal_static_ExceptionProtocol_fieldAccessorTable = new
|
|
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
|
|
internal_static_ExceptionProtocol_descriptor,
|
|
new java.lang.String[] { "Classname", "Message", },
|
|
akka.remote.protocol.RemoteProtocol.ExceptionProtocol.class,
|
|
akka.remote.protocol.RemoteProtocol.ExceptionProtocol.Builder.class);
|
|
return null;
|
|
}
|
|
};
|
|
com.google.protobuf.Descriptors.FileDescriptor
|
|
.internalBuildGeneratedFileFrom(descriptorData,
|
|
new com.google.protobuf.Descriptors.FileDescriptor[] {
|
|
}, assigner);
|
|
}
|
|
|
|
public static void internalForceInit() {}
|
|
|
|
// @@protoc_insertion_point(outer_class_scope)
|
|
}
|