From 914f4db513477d9aff726546bac47545195a3e37 Mon Sep 17 00:00:00 2001 From: Roy Ben-Shabat Date: Thu, 16 Nov 2017 13:38:56 +0200 Subject: Rename "Visual Studio" to "Visual_Studio" Rename "External Repositories" to "External_Repositories". --- .../java/com/twine/tango/pmr/MessageFactory.java | 163 ++++ .../java/com/twine/tango/pmr/TangoMessage.java | 91 ++ .../pmr/common/MessageContainerOuterClass.java | 869 +++++++++++++++++++ .../tango/pmr/common/MessageTypeOuterClass.java | 191 +++++ .../com/twine/tango/pmr/common/RGBOuterClass.java | 630 ++++++++++++++ .../com/twine/tango/pmr/jobs/JobOuterClass.java | 953 +++++++++++++++++++++ .../twine/tango/pmr/jobs/SegmentOuterClass.java | 838 ++++++++++++++++++ .../pmr/stubs/CalculateRequestOuterClass.java | 573 +++++++++++++ .../pmr/stubs/CalculateResponseOuterClass.java | 507 +++++++++++ .../tango/pmr/stubs/ProgressRequestOuterClass.java | 440 ++++++++++ .../pmr/stubs/ProgressResponseOuterClass.java | 507 +++++++++++ 11 files changed, 5762 insertions(+) create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/MessageFactory.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/TangoMessage.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageContainerOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageTypeOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/RGBOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/JobOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/SegmentOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateRequestOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateResponseOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressRequestOuterClass.java create mode 100644 Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressResponseOuterClass.java (limited to 'Software/Android_Studio/Tango.PMR/src/main/java/com') diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/MessageFactory.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/MessageFactory.java new file mode 100644 index 000000000..04acf5248 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/MessageFactory.java @@ -0,0 +1,163 @@ +package com.twine.tango.pmr; + +import android.content.Context; + +import com.elvishew.xlog.XLog; +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.Parser; +import com.twine.tango.core.Reflections; +import com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer; +import com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Contains helper method for generating {@link TangoMessage} messages. + */ +public class MessageFactory +{ + private static boolean initialized; + private static List packages; + private static Map knownClasses; + + + public static void init() + { + if (!initialized) + { + packages = new ArrayList<>(); + knownClasses = new HashMap<>(); + + List names = Reflections.getReflectionListFromResource(R.raw.packages); + + for (String name : names) + { + packages.add("com.twine.tango.pmr." + name); + } + + initialized = true; + } + } + + private static Class getClassForName(String name) + { + init(); + + Class knownClass = knownClasses.get(name); + if (knownClass != null) return knownClass; + + for (String p : packages) + { + try + { + Class cls = Class.forName(p + "." + name + "OuterClass$" + name); + knownClasses.put(name, cls); + return cls; + } catch (ClassNotFoundException e) + { + e.printStackTrace(); + } + } + + + XLog.e("Could not find PMR message class for " + name, new ClassNotFoundException()); + return null; + } + + /** + * Creates a new {@link TangoMessage} message wrapper. + * + * @param typeName The inner message class. + * @param Type of message. + * @return New instance of {@link TangoMessage}. + */ + public static TangoMessage createTangoMessage(Class typeName) + { + try + { + String a = typeName.getSimpleName(); + + Method newBuilder = typeName.getMethod("newBuilder"); + Object builder = newBuilder.invoke(null); + + Method build = builder.getClass().getMethod("build"); + Object instance = build.invoke(builder); + + TangoMessage tangoMessage = new TangoMessage<>((T) instance, MessageType.valueOf(typeName.getSimpleName())); + return tangoMessage; + } catch (Exception e) + { + e.printStackTrace(); + return null; + } + } + + public static TangoMessage createTangoMessage(Class typeName, T message) + { + TangoMessage tangoMessage = createTangoMessage(typeName); + tangoMessage.setMessage(message); + return tangoMessage; + } + + public static TangoMessage createTangoMessage(Class typeName, String token) + { + TangoMessage tangoMessage = createTangoMessage(typeName); + tangoMessage.getContainer().setToken(token); + return tangoMessage; + } + + /** + * Parses a {@link MessageContainer} byte array to a new {@link TangoMessage}. + * + * @param data MessageContainer bytes. + * @param Type of expected inner message. + * @return New instance of {@link TangoMessage}. + */ + @SuppressWarnings("unchecked") + public static TangoMessage parseTangoMessage(byte[] data) + { + try + { + MessageContainer container = MessageContainer.parseFrom(data); + + Class type = getClassForName(container.getType().toString()); + Parser parser = (Parser) type.getMethod("parser").invoke(null); + TangoMessage tangoMessage = new TangoMessage<>(parser.parseFrom(container.getData()), container.getType()); + return tangoMessage; + } catch (Exception e) + { + e.printStackTrace(); + return null; + } + } + + public static T parseMessageFromContainer(MessageContainer container) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InvalidProtocolBufferException + { + + Class type = getClassForName(container.getType().toString()); + Parser parser = (Parser) type.getMethod("parser").invoke(null); + return (T) parser.parseFrom(container.getData()); + } + + public static com.google.protobuf.GeneratedMessageV3 parseMessageFromContainerAgnostic(MessageContainer container) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InvalidProtocolBufferException + { + Class type = getClassForName(container.getType().toString()); + Parser parser = (Parser) type.getMethod("parser").invoke(null); + return (com.google.protobuf.GeneratedMessageV3) parser.parseFrom(container.getData()); + } + + public static MessageContainer parseContainer(byte[] data) throws InvalidProtocolBufferException + { + MessageContainer container = MessageContainer.parseFrom(data); + return container; + } + +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/TangoMessage.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/TangoMessage.java new file mode 100644 index 000000000..48422575d --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/TangoMessage.java @@ -0,0 +1,91 @@ +package com.twine.tango.pmr; + +import com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer; +import com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType; + +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.UUID; + +/** + * Generic Tango message wrapper. + * @param + */ +public class TangoMessage { + + private T message; + private MessageType type; + private MessageContainer.Builder container; + + /** + * Initialize a new instance of Tango message. + * @param message The message. + * @param type The message type. + */ + public TangoMessage(T message, MessageType type) { + this.message = message; + this.type = type; + + this.container = MessageContainer.newBuilder() + .setToken(UUID.randomUUID().toString()) + .setType(type); + } + + /** + * Gets the inner message. + * @return The inner message. + */ + public T getMessage() { + return message; + } + + /** + * Sets the inner message. + * @param message The inner message. + */ + public void setMessage(T message) { + this.message = message; + } + + /** + * Gets the inner message type. + * @return The inner message type. + */ + public MessageType getType() { + return type; + } + + /** + * Sets the inner message type. + * @param type Inner message type. + */ + public void setType(MessageType type) { + this.type = type; + } + + /** + * Gets the message container. + * @return the message container. + */ + public MessageContainer.Builder getContainer() { + return container; + } + + /** + * Sets the message container. + * @param container + */ + public void setContainer(MessageContainer.Builder container) { + this.container = container; + } + + /** + * Serializes the container and message to byte array. + * @return Container and message byte array. + */ + public byte[] toBytes() + { + container.setData(message.toByteString()); + return container.build().toByteArray(); + } +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageContainerOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageContainerOuterClass.java new file mode 100644 index 000000000..c4919dae3 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageContainerOuterClass.java @@ -0,0 +1,869 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: MessageContainer.proto + +package com.twine.tango.pmr.common; + +public final class MessageContainerOuterClass { + private MessageContainerOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface MessageContainerOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Common.MessageContainer) + com.google.protobuf.MessageOrBuilder { + + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + int getTypeValue(); + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType getType(); + + /** + * string Token = 2; + */ + java.lang.String getToken(); + /** + * string Token = 2; + */ + com.google.protobuf.ByteString + getTokenBytes(); + + /** + * bool Continuous = 3; + */ + boolean getContinuous(); + + /** + * bool Completed = 4; + */ + boolean getCompleted(); + + /** + * bytes Data = 5; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code Tango.PMR.Common.MessageContainer} + */ + public static final class MessageContainer extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Common.MessageContainer) + MessageContainerOrBuilder { + private static final long serialVersionUID = 0L; + // Use MessageContainer.newBuilder() to construct. + private MessageContainer(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private MessageContainer() { + type_ = 0; + token_ = ""; + continuous_ = false; + completed_ = false; + data_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private MessageContainer( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + + type_ = rawValue; + break; + } + case 18: { + java.lang.String s = input.readStringRequireUtf8(); + + token_ = s; + break; + } + case 24: { + + continuous_ = input.readBool(); + break; + } + case 32: { + + completed_ = input.readBool(); + break; + } + case 42: { + + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.internal_static_Tango_PMR_Common_MessageContainer_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.internal_static_Tango_PMR_Common_MessageContainer_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.class, com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.Builder.class); + } + + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType getType() { + com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType result = com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.valueOf(type_); + return result == null ? com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.UNRECOGNIZED : result; + } + + public static final int TOKEN_FIELD_NUMBER = 2; + private volatile java.lang.Object token_; + /** + * string Token = 2; + */ + public java.lang.String getToken() { + java.lang.Object ref = token_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + token_ = s; + return s; + } + } + /** + * string Token = 2; + */ + public com.google.protobuf.ByteString + getTokenBytes() { + java.lang.Object ref = token_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + token_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int CONTINUOUS_FIELD_NUMBER = 3; + private boolean continuous_; + /** + * bool Continuous = 3; + */ + public boolean getContinuous() { + return continuous_; + } + + public static final int COMPLETED_FIELD_NUMBER = 4; + private boolean completed_; + /** + * bool Completed = 4; + */ + public boolean getCompleted() { + return completed_; + } + + public static final int DATA_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString data_; + /** + * bytes Data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (type_ != com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.RGB.getNumber()) { + output.writeEnum(1, type_); + } + if (!getTokenBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, token_); + } + if (continuous_ != false) { + output.writeBool(3, continuous_); + } + if (completed_ != false) { + output.writeBool(4, completed_); + } + if (!data_.isEmpty()) { + output.writeBytes(5, data_); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (type_ != com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.RGB.getNumber()) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (!getTokenBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, token_); + } + if (continuous_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, continuous_); + } + if (completed_ != false) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(4, completed_); + } + if (!data_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, data_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer)) { + return super.equals(obj); + } + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer other = (com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer) obj; + + boolean result = true; + result = result && type_ == other.type_; + result = result && getToken() + .equals(other.getToken()); + result = result && (getContinuous() + == other.getContinuous()); + result = result && (getCompleted() + == other.getCompleted()); + result = result && getData() + .equals(other.getData()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + hash = (37 * hash) + TOKEN_FIELD_NUMBER; + hash = (53 * hash) + getToken().hashCode(); + hash = (37 * hash) + CONTINUOUS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getContinuous()); + hash = (37 * hash) + COMPLETED_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCompleted()); + hash = (37 * hash) + DATA_FIELD_NUMBER; + hash = (53 * hash) + getData().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Common.MessageContainer} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Common.MessageContainer) + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainerOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.internal_static_Tango_PMR_Common_MessageContainer_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.internal_static_Tango_PMR_Common_MessageContainer_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.class, com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.Builder.class); + } + + // Construct using com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + type_ = 0; + + token_ = ""; + + continuous_ = false; + + completed_ = false; + + data_ = com.google.protobuf.ByteString.EMPTY; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.internal_static_Tango_PMR_Common_MessageContainer_descriptor; + } + + public com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer getDefaultInstanceForType() { + return com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.getDefaultInstance(); + } + + public com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer build() { + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer buildPartial() { + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer result = new com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer(this); + result.type_ = type_; + result.token_ = token_; + result.continuous_ = continuous_; + result.completed_ = completed_; + result.data_ = data_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer) { + return mergeFrom((com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer other) { + if (other == com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer.getDefaultInstance()) return this; + if (other.type_ != 0) { + setTypeValue(other.getTypeValue()); + } + if (!other.getToken().isEmpty()) { + token_ = other.token_; + onChanged(); + } + if (other.getContinuous() != false) { + setContinuous(other.getContinuous()); + } + if (other.getCompleted() != false) { + setCompleted(other.getCompleted()); + } + if (other.getData() != com.google.protobuf.ByteString.EMPTY) { + setData(other.getData()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int type_ = 0; + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public int getTypeValue() { + return type_; + } + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public Builder setTypeValue(int value) { + type_ = value; + onChanged(); + return this; + } + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType getType() { + com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType result = com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.valueOf(type_); + return result == null ? com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType.UNRECOGNIZED : result; + } + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public Builder setType(com.twine.tango.pmr.common.MessageTypeOuterClass.MessageType value) { + if (value == null) { + throw new NullPointerException(); + } + + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * .Tango.PMR.Common.MessageType Type = 1; + */ + public Builder clearType() { + + type_ = 0; + onChanged(); + return this; + } + + private java.lang.Object token_ = ""; + /** + * string Token = 2; + */ + public java.lang.String getToken() { + java.lang.Object ref = token_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + token_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string Token = 2; + */ + public com.google.protobuf.ByteString + getTokenBytes() { + java.lang.Object ref = token_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + token_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string Token = 2; + */ + public Builder setToken( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + token_ = value; + onChanged(); + return this; + } + /** + * string Token = 2; + */ + public Builder clearToken() { + + token_ = getDefaultInstance().getToken(); + onChanged(); + return this; + } + /** + * string Token = 2; + */ + public Builder setTokenBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + token_ = value; + onChanged(); + return this; + } + + private boolean continuous_ ; + /** + * bool Continuous = 3; + */ + public boolean getContinuous() { + return continuous_; + } + /** + * bool Continuous = 3; + */ + public Builder setContinuous(boolean value) { + + continuous_ = value; + onChanged(); + return this; + } + /** + * bool Continuous = 3; + */ + public Builder clearContinuous() { + + continuous_ = false; + onChanged(); + return this; + } + + private boolean completed_ ; + /** + * bool Completed = 4; + */ + public boolean getCompleted() { + return completed_; + } + /** + * bool Completed = 4; + */ + public Builder setCompleted(boolean value) { + + completed_ = value; + onChanged(); + return this; + } + /** + * bool Completed = 4; + */ + public Builder clearCompleted() { + + completed_ = false; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes Data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * bytes Data = 5; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + data_ = value; + onChanged(); + return this; + } + /** + * bytes Data = 5; + */ + public Builder clearData() { + + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Common.MessageContainer) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Common.MessageContainer) + private static final com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer(); + } + + public static com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public MessageContainer parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new MessageContainer(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.common.MessageContainerOuterClass.MessageContainer getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Common_MessageContainer_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Common_MessageContainer_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\026MessageContainer.proto\022\020Tango.PMR.Comm" + + "on\032\021MessageType.proto\"\203\001\n\020MessageContain" + + "er\022+\n\004Type\030\001 \001(\0162\035.Tango.PMR.Common.Mess" + + "ageType\022\r\n\005Token\030\002 \001(\t\022\022\n\nContinuous\030\003 \001" + + "(\010\022\021\n\tCompleted\030\004 \001(\010\022\014\n\004Data\030\005 \001(\014B\034\n\032c" + + "om.twine.tango.pmr.commonb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.twine.tango.pmr.common.MessageTypeOuterClass.getDescriptor(), + }, assigner); + internal_static_Tango_PMR_Common_MessageContainer_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Common_MessageContainer_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Common_MessageContainer_descriptor, + new java.lang.String[] { "Type", "Token", "Continuous", "Completed", "Data", }); + com.twine.tango.pmr.common.MessageTypeOuterClass.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageTypeOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageTypeOuterClass.java new file mode 100644 index 000000000..45185ab6d --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/MessageTypeOuterClass.java @@ -0,0 +1,191 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: MessageType.proto + +package com.twine.tango.pmr.common; + +public final class MessageTypeOuterClass { + private MessageTypeOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + /** + * Protobuf enum {@code Tango.PMR.Common.MessageType} + */ + public enum MessageType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * RGB = 0; + */ + RGB(0), + /** + * Job = 1; + */ + Job(1), + /** + * Segment = 2; + */ + Segment(2), + /** + * CalculateRequest = 3; + */ + CalculateRequest(3), + /** + * CalculateResponse = 4; + */ + CalculateResponse(4), + /** + * ProgressRequest = 5; + */ + ProgressRequest(5), + /** + * ProgressResponse = 6; + */ + ProgressResponse(6), + UNRECOGNIZED(-1), + ; + + /** + * RGB = 0; + */ + public static final int RGB_VALUE = 0; + /** + * Job = 1; + */ + public static final int Job_VALUE = 1; + /** + * Segment = 2; + */ + public static final int Segment_VALUE = 2; + /** + * CalculateRequest = 3; + */ + public static final int CalculateRequest_VALUE = 3; + /** + * CalculateResponse = 4; + */ + public static final int CalculateResponse_VALUE = 4; + /** + * ProgressRequest = 5; + */ + public static final int ProgressRequest_VALUE = 5; + /** + * ProgressResponse = 6; + */ + public static final int ProgressResponse_VALUE = 6; + + + public final int getNumber() { + if (this == UNRECOGNIZED) { + throw new java.lang.IllegalArgumentException( + "Can't get the number of an unknown enum value."); + } + return value; + } + + /** + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static MessageType valueOf(int value) { + return forNumber(value); + } + + public static MessageType forNumber(int value) { + switch (value) { + case 0: return RGB; + case 1: return Job; + case 2: return Segment; + case 3: return CalculateRequest; + case 4: return CalculateResponse; + case 5: return ProgressRequest; + case 6: return ProgressResponse; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + MessageType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public MessageType findValueByNumber(int number) { + return MessageType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.twine.tango.pmr.common.MessageTypeOuterClass.getDescriptor().getEnumTypes().get(0); + } + + private static final MessageType[] VALUES = values(); + + public static MessageType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + if (desc.getIndex() == -1) { + return UNRECOGNIZED; + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private MessageType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Tango.PMR.Common.MessageType) + } + + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\021MessageType.proto\022\020Tango.PMR.Common*\204\001" + + "\n\013MessageType\022\007\n\003RGB\020\000\022\007\n\003Job\020\001\022\013\n\007Segme" + + "nt\020\002\022\024\n\020CalculateRequest\020\003\022\025\n\021CalculateR" + + "esponse\020\004\022\023\n\017ProgressRequest\020\005\022\024\n\020Progre" + + "ssResponse\020\006B\034\n\032com.twine.tango.pmr.comm" + + "onb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/RGBOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/RGBOuterClass.java new file mode 100644 index 000000000..4e751dd48 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/common/RGBOuterClass.java @@ -0,0 +1,630 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: RGB.proto + +package com.twine.tango.pmr.common; + +public final class RGBOuterClass { + private RGBOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface RGBOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Common.RGB) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 R = 1; + */ + int getR(); + + /** + * int32 G = 2; + */ + int getG(); + + /** + * int32 B = 3; + */ + int getB(); + } + /** + * Protobuf type {@code Tango.PMR.Common.RGB} + */ + public static final class RGB extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Common.RGB) + RGBOrBuilder { + private static final long serialVersionUID = 0L; + // Use RGB.newBuilder() to construct. + private RGB(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private RGB() { + r_ = 0; + g_ = 0; + b_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private RGB( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + + r_ = input.readInt32(); + break; + } + case 16: { + + g_ = input.readInt32(); + break; + } + case 24: { + + b_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.common.RGBOuterClass.internal_static_Tango_PMR_Common_RGB_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.common.RGBOuterClass.internal_static_Tango_PMR_Common_RGB_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.common.RGBOuterClass.RGB.class, com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder.class); + } + + public static final int R_FIELD_NUMBER = 1; + private int r_; + /** + * int32 R = 1; + */ + public int getR() { + return r_; + } + + public static final int G_FIELD_NUMBER = 2; + private int g_; + /** + * int32 G = 2; + */ + public int getG() { + return g_; + } + + public static final int B_FIELD_NUMBER = 3; + private int b_; + /** + * int32 B = 3; + */ + public int getB() { + return b_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (r_ != 0) { + output.writeInt32(1, r_); + } + if (g_ != 0) { + output.writeInt32(2, g_); + } + if (b_ != 0) { + output.writeInt32(3, b_); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (r_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, r_); + } + if (g_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, g_); + } + if (b_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, b_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.common.RGBOuterClass.RGB)) { + return super.equals(obj); + } + com.twine.tango.pmr.common.RGBOuterClass.RGB other = (com.twine.tango.pmr.common.RGBOuterClass.RGB) obj; + + boolean result = true; + result = result && (getR() + == other.getR()); + result = result && (getG() + == other.getG()); + result = result && (getB() + == other.getB()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + R_FIELD_NUMBER; + hash = (53 * hash) + getR(); + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + getG(); + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getB(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.common.RGBOuterClass.RGB parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.common.RGBOuterClass.RGB prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Common.RGB} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Common.RGB) + com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.common.RGBOuterClass.internal_static_Tango_PMR_Common_RGB_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.common.RGBOuterClass.internal_static_Tango_PMR_Common_RGB_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.common.RGBOuterClass.RGB.class, com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder.class); + } + + // Construct using com.twine.tango.pmr.common.RGBOuterClass.RGB.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + r_ = 0; + + g_ = 0; + + b_ = 0; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.common.RGBOuterClass.internal_static_Tango_PMR_Common_RGB_descriptor; + } + + public com.twine.tango.pmr.common.RGBOuterClass.RGB getDefaultInstanceForType() { + return com.twine.tango.pmr.common.RGBOuterClass.RGB.getDefaultInstance(); + } + + public com.twine.tango.pmr.common.RGBOuterClass.RGB build() { + com.twine.tango.pmr.common.RGBOuterClass.RGB result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.common.RGBOuterClass.RGB buildPartial() { + com.twine.tango.pmr.common.RGBOuterClass.RGB result = new com.twine.tango.pmr.common.RGBOuterClass.RGB(this); + result.r_ = r_; + result.g_ = g_; + result.b_ = b_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.common.RGBOuterClass.RGB) { + return mergeFrom((com.twine.tango.pmr.common.RGBOuterClass.RGB)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.common.RGBOuterClass.RGB other) { + if (other == com.twine.tango.pmr.common.RGBOuterClass.RGB.getDefaultInstance()) return this; + if (other.getR() != 0) { + setR(other.getR()); + } + if (other.getG() != 0) { + setG(other.getG()); + } + if (other.getB() != 0) { + setB(other.getB()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.common.RGBOuterClass.RGB parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.common.RGBOuterClass.RGB) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int r_ ; + /** + * int32 R = 1; + */ + public int getR() { + return r_; + } + /** + * int32 R = 1; + */ + public Builder setR(int value) { + + r_ = value; + onChanged(); + return this; + } + /** + * int32 R = 1; + */ + public Builder clearR() { + + r_ = 0; + onChanged(); + return this; + } + + private int g_ ; + /** + * int32 G = 2; + */ + public int getG() { + return g_; + } + /** + * int32 G = 2; + */ + public Builder setG(int value) { + + g_ = value; + onChanged(); + return this; + } + /** + * int32 G = 2; + */ + public Builder clearG() { + + g_ = 0; + onChanged(); + return this; + } + + private int b_ ; + /** + * int32 B = 3; + */ + public int getB() { + return b_; + } + /** + * int32 B = 3; + */ + public Builder setB(int value) { + + b_ = value; + onChanged(); + return this; + } + /** + * int32 B = 3; + */ + public Builder clearB() { + + b_ = 0; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Common.RGB) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Common.RGB) + private static final com.twine.tango.pmr.common.RGBOuterClass.RGB DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.common.RGBOuterClass.RGB(); + } + + public static com.twine.tango.pmr.common.RGBOuterClass.RGB getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public RGB parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new RGB(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.common.RGBOuterClass.RGB getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Common_RGB_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Common_RGB_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\tRGB.proto\022\020Tango.PMR.Common\"&\n\003RGB\022\t\n\001" + + "R\030\001 \001(\005\022\t\n\001G\030\002 \001(\005\022\t\n\001B\030\003 \001(\005B\034\n\032com.twi" + + "ne.tango.pmr.commonb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_Tango_PMR_Common_RGB_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Common_RGB_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Common_RGB_descriptor, + new java.lang.String[] { "R", "G", "B", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/JobOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/JobOuterClass.java new file mode 100644 index 000000000..79c17d6a8 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/JobOuterClass.java @@ -0,0 +1,953 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Job.proto + +package com.twine.tango.pmr.jobs; + +public final class JobOuterClass { + private JobOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface JobOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Jobs.Job) + com.google.protobuf.MessageOrBuilder { + + /** + * string Name = 1; + */ + java.lang.String getName(); + /** + * string Name = 1; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + java.util.List + getSegmentsList(); + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getSegments(int index); + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + int getSegmentsCount(); + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + java.util.List + getSegmentsOrBuilderList(); + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder getSegmentsOrBuilder( + int index); + } + /** + * Protobuf type {@code Tango.PMR.Jobs.Job} + */ + public static final class Job extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Jobs.Job) + JobOrBuilder { + private static final long serialVersionUID = 0L; + // Use Job.newBuilder() to construct. + private Job(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Job() { + name_ = ""; + segments_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Job( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + segments_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + segments_.add( + input.readMessage(com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.parser(), extensionRegistry)); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + segments_ = java.util.Collections.unmodifiableList(segments_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.jobs.JobOuterClass.internal_static_Tango_PMR_Jobs_Job_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.jobs.JobOuterClass.internal_static_Tango_PMR_Jobs_Job_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.jobs.JobOuterClass.Job.class, com.twine.tango.pmr.jobs.JobOuterClass.Job.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * string Name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string Name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SEGMENTS_FIELD_NUMBER = 2; + private java.util.List segments_; + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public java.util.List getSegmentsList() { + return segments_; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public java.util.List + getSegmentsOrBuilderList() { + return segments_; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public int getSegmentsCount() { + return segments_.size(); + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getSegments(int index) { + return segments_.get(index); + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder getSegmentsOrBuilder( + int index) { + return segments_.get(index); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + for (int i = 0; i < segments_.size(); i++) { + output.writeMessage(2, segments_.get(i)); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + for (int i = 0; i < segments_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, segments_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.jobs.JobOuterClass.Job)) { + return super.equals(obj); + } + com.twine.tango.pmr.jobs.JobOuterClass.Job other = (com.twine.tango.pmr.jobs.JobOuterClass.Job) obj; + + boolean result = true; + result = result && getName() + .equals(other.getName()); + result = result && getSegmentsList() + .equals(other.getSegmentsList()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + if (getSegmentsCount() > 0) { + hash = (37 * hash) + SEGMENTS_FIELD_NUMBER; + hash = (53 * hash) + getSegmentsList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.JobOuterClass.Job parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.jobs.JobOuterClass.Job prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Jobs.Job} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Jobs.Job) + com.twine.tango.pmr.jobs.JobOuterClass.JobOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.jobs.JobOuterClass.internal_static_Tango_PMR_Jobs_Job_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.jobs.JobOuterClass.internal_static_Tango_PMR_Jobs_Job_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.jobs.JobOuterClass.Job.class, com.twine.tango.pmr.jobs.JobOuterClass.Job.Builder.class); + } + + // Construct using com.twine.tango.pmr.jobs.JobOuterClass.Job.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getSegmentsFieldBuilder(); + } + } + public Builder clear() { + super.clear(); + name_ = ""; + + if (segmentsBuilder_ == null) { + segments_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + segmentsBuilder_.clear(); + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.jobs.JobOuterClass.internal_static_Tango_PMR_Jobs_Job_descriptor; + } + + public com.twine.tango.pmr.jobs.JobOuterClass.Job getDefaultInstanceForType() { + return com.twine.tango.pmr.jobs.JobOuterClass.Job.getDefaultInstance(); + } + + public com.twine.tango.pmr.jobs.JobOuterClass.Job build() { + com.twine.tango.pmr.jobs.JobOuterClass.Job result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.jobs.JobOuterClass.Job buildPartial() { + com.twine.tango.pmr.jobs.JobOuterClass.Job result = new com.twine.tango.pmr.jobs.JobOuterClass.Job(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + result.name_ = name_; + if (segmentsBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002)) { + segments_ = java.util.Collections.unmodifiableList(segments_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.segments_ = segments_; + } else { + result.segments_ = segmentsBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.jobs.JobOuterClass.Job) { + return mergeFrom((com.twine.tango.pmr.jobs.JobOuterClass.Job)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.jobs.JobOuterClass.Job other) { + if (other == com.twine.tango.pmr.jobs.JobOuterClass.Job.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (segmentsBuilder_ == null) { + if (!other.segments_.isEmpty()) { + if (segments_.isEmpty()) { + segments_ = other.segments_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureSegmentsIsMutable(); + segments_.addAll(other.segments_); + } + onChanged(); + } + } else { + if (!other.segments_.isEmpty()) { + if (segmentsBuilder_.isEmpty()) { + segmentsBuilder_.dispose(); + segmentsBuilder_ = null; + segments_ = other.segments_; + bitField0_ = (bitField0_ & ~0x00000002); + segmentsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getSegmentsFieldBuilder() : null; + } else { + segmentsBuilder_.addAllMessages(other.segments_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.jobs.JobOuterClass.Job parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.jobs.JobOuterClass.Job) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * string Name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string Name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string Name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string Name = 1; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string Name = 1; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private java.util.List segments_ = + java.util.Collections.emptyList(); + private void ensureSegmentsIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + segments_ = new java.util.ArrayList(segments_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder, com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder> segmentsBuilder_; + + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public java.util.List getSegmentsList() { + if (segmentsBuilder_ == null) { + return java.util.Collections.unmodifiableList(segments_); + } else { + return segmentsBuilder_.getMessageList(); + } + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public int getSegmentsCount() { + if (segmentsBuilder_ == null) { + return segments_.size(); + } else { + return segmentsBuilder_.getCount(); + } + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getSegments(int index) { + if (segmentsBuilder_ == null) { + return segments_.get(index); + } else { + return segmentsBuilder_.getMessage(index); + } + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder setSegments( + int index, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment value) { + if (segmentsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSegmentsIsMutable(); + segments_.set(index, value); + onChanged(); + } else { + segmentsBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder setSegments( + int index, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder builderForValue) { + if (segmentsBuilder_ == null) { + ensureSegmentsIsMutable(); + segments_.set(index, builderForValue.build()); + onChanged(); + } else { + segmentsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder addSegments(com.twine.tango.pmr.jobs.SegmentOuterClass.Segment value) { + if (segmentsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSegmentsIsMutable(); + segments_.add(value); + onChanged(); + } else { + segmentsBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder addSegments( + int index, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment value) { + if (segmentsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureSegmentsIsMutable(); + segments_.add(index, value); + onChanged(); + } else { + segmentsBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder addSegments( + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder builderForValue) { + if (segmentsBuilder_ == null) { + ensureSegmentsIsMutable(); + segments_.add(builderForValue.build()); + onChanged(); + } else { + segmentsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder addSegments( + int index, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder builderForValue) { + if (segmentsBuilder_ == null) { + ensureSegmentsIsMutable(); + segments_.add(index, builderForValue.build()); + onChanged(); + } else { + segmentsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder addAllSegments( + java.lang.Iterable values) { + if (segmentsBuilder_ == null) { + ensureSegmentsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, segments_); + onChanged(); + } else { + segmentsBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder clearSegments() { + if (segmentsBuilder_ == null) { + segments_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + segmentsBuilder_.clear(); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public Builder removeSegments(int index) { + if (segmentsBuilder_ == null) { + ensureSegmentsIsMutable(); + segments_.remove(index); + onChanged(); + } else { + segmentsBuilder_.remove(index); + } + return this; + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder getSegmentsBuilder( + int index) { + return getSegmentsFieldBuilder().getBuilder(index); + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder getSegmentsOrBuilder( + int index) { + if (segmentsBuilder_ == null) { + return segments_.get(index); } else { + return segmentsBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public java.util.List + getSegmentsOrBuilderList() { + if (segmentsBuilder_ != null) { + return segmentsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(segments_); + } + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder addSegmentsBuilder() { + return getSegmentsFieldBuilder().addBuilder( + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.getDefaultInstance()); + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder addSegmentsBuilder( + int index) { + return getSegmentsFieldBuilder().addBuilder( + index, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.getDefaultInstance()); + } + /** + * repeated .Tango.PMR.Jobs.Segment Segments = 2; + */ + public java.util.List + getSegmentsBuilderList() { + return getSegmentsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder, com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder> + getSegmentsFieldBuilder() { + if (segmentsBuilder_ == null) { + segmentsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder, com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder>( + segments_, + ((bitField0_ & 0x00000002) == 0x00000002), + getParentForChildren(), + isClean()); + segments_ = null; + } + return segmentsBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Jobs.Job) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Jobs.Job) + private static final com.twine.tango.pmr.jobs.JobOuterClass.Job DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.jobs.JobOuterClass.Job(); + } + + public static com.twine.tango.pmr.jobs.JobOuterClass.Job getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Job parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Job(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.jobs.JobOuterClass.Job getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Jobs_Job_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Jobs_Job_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\tJob.proto\022\016Tango.PMR.Jobs\032\rSegment.pro" + + "to\">\n\003Job\022\014\n\004Name\030\001 \001(\t\022)\n\010Segments\030\002 \003(" + + "\0132\027.Tango.PMR.Jobs.SegmentB\032\n\030com.twine." + + "tango.pmr.jobsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.twine.tango.pmr.jobs.SegmentOuterClass.getDescriptor(), + }, assigner); + internal_static_Tango_PMR_Jobs_Job_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Jobs_Job_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Jobs_Job_descriptor, + new java.lang.String[] { "Name", "Segments", }); + com.twine.tango.pmr.jobs.SegmentOuterClass.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/SegmentOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/SegmentOuterClass.java new file mode 100644 index 000000000..eb19e884e --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/jobs/SegmentOuterClass.java @@ -0,0 +1,838 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: Segment.proto + +package com.twine.tango.pmr.jobs; + +public final class SegmentOuterClass { + private SegmentOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface SegmentOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Jobs.Segment) + com.google.protobuf.MessageOrBuilder { + + /** + * string Name = 1; + */ + java.lang.String getName(); + /** + * string Name = 1; + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * int32 Length = 2; + */ + int getLength(); + + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + boolean hasColor(); + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + com.twine.tango.pmr.common.RGBOuterClass.RGB getColor(); + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder getColorOrBuilder(); + } + /** + * Protobuf type {@code Tango.PMR.Jobs.Segment} + */ + public static final class Segment extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Jobs.Segment) + SegmentOrBuilder { + private static final long serialVersionUID = 0L; + // Use Segment.newBuilder() to construct. + private Segment(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Segment() { + name_ = ""; + length_ = 0; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Segment( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + java.lang.String s = input.readStringRequireUtf8(); + + name_ = s; + break; + } + case 16: { + + length_ = input.readInt32(); + break; + } + case 26: { + com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder subBuilder = null; + if (color_ != null) { + subBuilder = color_.toBuilder(); + } + color_ = input.readMessage(com.twine.tango.pmr.common.RGBOuterClass.RGB.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(color_); + color_ = subBuilder.buildPartial(); + } + + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.internal_static_Tango_PMR_Jobs_Segment_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.internal_static_Tango_PMR_Jobs_Segment_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.class, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder.class); + } + + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * string Name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * string Name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int LENGTH_FIELD_NUMBER = 2; + private int length_; + /** + * int32 Length = 2; + */ + public int getLength() { + return length_; + } + + public static final int COLOR_FIELD_NUMBER = 3; + private com.twine.tango.pmr.common.RGBOuterClass.RGB color_; + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public boolean hasColor() { + return color_ != null; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public com.twine.tango.pmr.common.RGBOuterClass.RGB getColor() { + return color_ == null ? com.twine.tango.pmr.common.RGBOuterClass.RGB.getDefaultInstance() : color_; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder getColorOrBuilder() { + return getColor(); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getNameBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (length_ != 0) { + output.writeInt32(2, length_); + } + if (color_ != null) { + output.writeMessage(3, getColor()); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getNameBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (length_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, length_); + } + if (color_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getColor()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.jobs.SegmentOuterClass.Segment)) { + return super.equals(obj); + } + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment other = (com.twine.tango.pmr.jobs.SegmentOuterClass.Segment) obj; + + boolean result = true; + result = result && getName() + .equals(other.getName()); + result = result && (getLength() + == other.getLength()); + result = result && (hasColor() == other.hasColor()); + if (hasColor()) { + result = result && getColor() + .equals(other.getColor()); + } + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (37 * hash) + LENGTH_FIELD_NUMBER; + hash = (53 * hash) + getLength(); + if (hasColor()) { + hash = (37 * hash) + COLOR_FIELD_NUMBER; + hash = (53 * hash) + getColor().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.jobs.SegmentOuterClass.Segment prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Jobs.Segment} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Jobs.Segment) + com.twine.tango.pmr.jobs.SegmentOuterClass.SegmentOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.internal_static_Tango_PMR_Jobs_Segment_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.internal_static_Tango_PMR_Jobs_Segment_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.class, com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.Builder.class); + } + + // Construct using com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + name_ = ""; + + length_ = 0; + + if (colorBuilder_ == null) { + color_ = null; + } else { + color_ = null; + colorBuilder_ = null; + } + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.internal_static_Tango_PMR_Jobs_Segment_descriptor; + } + + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getDefaultInstanceForType() { + return com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.getDefaultInstance(); + } + + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment build() { + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment buildPartial() { + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment result = new com.twine.tango.pmr.jobs.SegmentOuterClass.Segment(this); + result.name_ = name_; + result.length_ = length_; + if (colorBuilder_ == null) { + result.color_ = color_; + } else { + result.color_ = colorBuilder_.build(); + } + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.jobs.SegmentOuterClass.Segment) { + return mergeFrom((com.twine.tango.pmr.jobs.SegmentOuterClass.Segment)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.jobs.SegmentOuterClass.Segment other) { + if (other == com.twine.tango.pmr.jobs.SegmentOuterClass.Segment.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + onChanged(); + } + if (other.getLength() != 0) { + setLength(other.getLength()); + } + if (other.hasColor()) { + mergeColor(other.getColor()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.jobs.SegmentOuterClass.Segment parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.jobs.SegmentOuterClass.Segment) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private java.lang.Object name_ = ""; + /** + * string Name = 1; + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * string Name = 1; + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string Name = 1; + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + + name_ = value; + onChanged(); + return this; + } + /** + * string Name = 1; + */ + public Builder clearName() { + + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * string Name = 1; + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + name_ = value; + onChanged(); + return this; + } + + private int length_ ; + /** + * int32 Length = 2; + */ + public int getLength() { + return length_; + } + /** + * int32 Length = 2; + */ + public Builder setLength(int value) { + + length_ = value; + onChanged(); + return this; + } + /** + * int32 Length = 2; + */ + public Builder clearLength() { + + length_ = 0; + onChanged(); + return this; + } + + private com.twine.tango.pmr.common.RGBOuterClass.RGB color_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + com.twine.tango.pmr.common.RGBOuterClass.RGB, com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder, com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder> colorBuilder_; + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public boolean hasColor() { + return colorBuilder_ != null || color_ != null; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public com.twine.tango.pmr.common.RGBOuterClass.RGB getColor() { + if (colorBuilder_ == null) { + return color_ == null ? com.twine.tango.pmr.common.RGBOuterClass.RGB.getDefaultInstance() : color_; + } else { + return colorBuilder_.getMessage(); + } + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public Builder setColor(com.twine.tango.pmr.common.RGBOuterClass.RGB value) { + if (colorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + color_ = value; + onChanged(); + } else { + colorBuilder_.setMessage(value); + } + + return this; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public Builder setColor( + com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder builderForValue) { + if (colorBuilder_ == null) { + color_ = builderForValue.build(); + onChanged(); + } else { + colorBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public Builder mergeColor(com.twine.tango.pmr.common.RGBOuterClass.RGB value) { + if (colorBuilder_ == null) { + if (color_ != null) { + color_ = + com.twine.tango.pmr.common.RGBOuterClass.RGB.newBuilder(color_).mergeFrom(value).buildPartial(); + } else { + color_ = value; + } + onChanged(); + } else { + colorBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public Builder clearColor() { + if (colorBuilder_ == null) { + color_ = null; + onChanged(); + } else { + color_ = null; + colorBuilder_ = null; + } + + return this; + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder getColorBuilder() { + + onChanged(); + return getColorFieldBuilder().getBuilder(); + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + public com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder getColorOrBuilder() { + if (colorBuilder_ != null) { + return colorBuilder_.getMessageOrBuilder(); + } else { + return color_ == null ? + com.twine.tango.pmr.common.RGBOuterClass.RGB.getDefaultInstance() : color_; + } + } + /** + * .Tango.PMR.Common.RGB Color = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.twine.tango.pmr.common.RGBOuterClass.RGB, com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder, com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder> + getColorFieldBuilder() { + if (colorBuilder_ == null) { + colorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.twine.tango.pmr.common.RGBOuterClass.RGB, com.twine.tango.pmr.common.RGBOuterClass.RGB.Builder, com.twine.tango.pmr.common.RGBOuterClass.RGBOrBuilder>( + getColor(), + getParentForChildren(), + isClean()); + color_ = null; + } + return colorBuilder_; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Jobs.Segment) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Jobs.Segment) + private static final com.twine.tango.pmr.jobs.SegmentOuterClass.Segment DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.jobs.SegmentOuterClass.Segment(); + } + + public static com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public Segment parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Segment(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.jobs.SegmentOuterClass.Segment getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Jobs_Segment_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Jobs_Segment_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\rSegment.proto\022\016Tango.PMR.Jobs\032\tRGB.pro" + + "to\"M\n\007Segment\022\014\n\004Name\030\001 \001(\t\022\016\n\006Length\030\002 " + + "\001(\005\022$\n\005Color\030\003 \001(\0132\025.Tango.PMR.Common.RG" + + "BB\032\n\030com.twine.tango.pmr.jobsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.twine.tango.pmr.common.RGBOuterClass.getDescriptor(), + }, assigner); + internal_static_Tango_PMR_Jobs_Segment_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Jobs_Segment_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Jobs_Segment_descriptor, + new java.lang.String[] { "Name", "Length", "Color", }); + com.twine.tango.pmr.common.RGBOuterClass.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateRequestOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateRequestOuterClass.java new file mode 100644 index 000000000..09180939e --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateRequestOuterClass.java @@ -0,0 +1,573 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: CalculateRequest.proto + +package com.twine.tango.pmr.stubs; + +public final class CalculateRequestOuterClass { + private CalculateRequestOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface CalculateRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Stubs.CalculateRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * double A = 1; + */ + double getA(); + + /** + * double B = 2; + */ + double getB(); + } + /** + * Protobuf type {@code Tango.PMR.Stubs.CalculateRequest} + */ + public static final class CalculateRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Stubs.CalculateRequest) + CalculateRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use CalculateRequest.newBuilder() to construct. + private CalculateRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private CalculateRequest() { + a_ = 0D; + b_ = 0D; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CalculateRequest( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 9: { + + a_ = input.readDouble(); + break; + } + case 17: { + + b_ = input.readDouble(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.internal_static_Tango_PMR_Stubs_CalculateRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.class, com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private double a_; + /** + * double A = 1; + */ + public double getA() { + return a_; + } + + public static final int B_FIELD_NUMBER = 2; + private double b_; + /** + * double B = 2; + */ + public double getB() { + return b_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (a_ != 0D) { + output.writeDouble(1, a_); + } + if (b_ != 0D) { + output.writeDouble(2, b_); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (a_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(1, a_); + } + if (b_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(2, b_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest)) { + return super.equals(obj); + } + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest other = (com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest) obj; + + boolean result = true; + result = result && ( + java.lang.Double.doubleToLongBits(getA()) + == java.lang.Double.doubleToLongBits( + other.getA())); + result = result && ( + java.lang.Double.doubleToLongBits(getB()) + == java.lang.Double.doubleToLongBits( + other.getB())); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getA())); + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getB())); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Stubs.CalculateRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Stubs.CalculateRequest) + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.internal_static_Tango_PMR_Stubs_CalculateRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.class, com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.Builder.class); + } + + // Construct using com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + a_ = 0D; + + b_ = 0D; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor; + } + + public com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest getDefaultInstanceForType() { + return com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.getDefaultInstance(); + } + + public com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest build() { + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest buildPartial() { + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest result = new com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest(this); + result.a_ = a_; + result.b_ = b_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest) { + return mergeFrom((com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest other) { + if (other == com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest.getDefaultInstance()) return this; + if (other.getA() != 0D) { + setA(other.getA()); + } + if (other.getB() != 0D) { + setB(other.getB()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private double a_ ; + /** + * double A = 1; + */ + public double getA() { + return a_; + } + /** + * double A = 1; + */ + public Builder setA(double value) { + + a_ = value; + onChanged(); + return this; + } + /** + * double A = 1; + */ + public Builder clearA() { + + a_ = 0D; + onChanged(); + return this; + } + + private double b_ ; + /** + * double B = 2; + */ + public double getB() { + return b_; + } + /** + * double B = 2; + */ + public Builder setB(double value) { + + b_ = value; + onChanged(); + return this; + } + /** + * double B = 2; + */ + public Builder clearB() { + + b_ = 0D; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Stubs.CalculateRequest) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Stubs.CalculateRequest) + private static final com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest(); + } + + public static com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public CalculateRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CalculateRequest(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.stubs.CalculateRequestOuterClass.CalculateRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Stubs_CalculateRequest_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\026CalculateRequest.proto\022\017Tango.PMR.Stub" + + "s\"(\n\020CalculateRequest\022\t\n\001A\030\001 \001(\001\022\t\n\001B\030\002 " + + "\001(\001B\033\n\031com.twine.tango.pmr.stubsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Stubs_CalculateRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Stubs_CalculateRequest_descriptor, + new java.lang.String[] { "A", "B", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateResponseOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateResponseOuterClass.java new file mode 100644 index 000000000..b20ba95cd --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/CalculateResponseOuterClass.java @@ -0,0 +1,507 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: CalculateResponse.proto + +package com.twine.tango.pmr.stubs; + +public final class CalculateResponseOuterClass { + private CalculateResponseOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface CalculateResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Stubs.CalculateResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * double Sum = 1; + */ + double getSum(); + } + /** + * Protobuf type {@code Tango.PMR.Stubs.CalculateResponse} + */ + public static final class CalculateResponse extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Stubs.CalculateResponse) + CalculateResponseOrBuilder { + private static final long serialVersionUID = 0L; + // Use CalculateResponse.newBuilder() to construct. + private CalculateResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private CalculateResponse() { + sum_ = 0D; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CalculateResponse( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 9: { + + sum_ = input.readDouble(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.internal_static_Tango_PMR_Stubs_CalculateResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.class, com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.Builder.class); + } + + public static final int SUM_FIELD_NUMBER = 1; + private double sum_; + /** + * double Sum = 1; + */ + public double getSum() { + return sum_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (sum_ != 0D) { + output.writeDouble(1, sum_); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (sum_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(1, sum_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse)) { + return super.equals(obj); + } + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse other = (com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse) obj; + + boolean result = true; + result = result && ( + java.lang.Double.doubleToLongBits(getSum()) + == java.lang.Double.doubleToLongBits( + other.getSum())); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + SUM_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getSum())); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Stubs.CalculateResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Stubs.CalculateResponse) + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.internal_static_Tango_PMR_Stubs_CalculateResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.class, com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.Builder.class); + } + + // Construct using com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + sum_ = 0D; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor; + } + + public com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse getDefaultInstanceForType() { + return com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.getDefaultInstance(); + } + + public com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse build() { + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse buildPartial() { + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse result = new com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse(this); + result.sum_ = sum_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse) { + return mergeFrom((com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse other) { + if (other == com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse.getDefaultInstance()) return this; + if (other.getSum() != 0D) { + setSum(other.getSum()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private double sum_ ; + /** + * double Sum = 1; + */ + public double getSum() { + return sum_; + } + /** + * double Sum = 1; + */ + public Builder setSum(double value) { + + sum_ = value; + onChanged(); + return this; + } + /** + * double Sum = 1; + */ + public Builder clearSum() { + + sum_ = 0D; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Stubs.CalculateResponse) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Stubs.CalculateResponse) + private static final com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse(); + } + + public static com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public CalculateResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CalculateResponse(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.stubs.CalculateResponseOuterClass.CalculateResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Stubs_CalculateResponse_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\027CalculateResponse.proto\022\017Tango.PMR.Stu" + + "bs\" \n\021CalculateResponse\022\013\n\003Sum\030\001 \001(\001B\033\n\031" + + "com.twine.tango.pmr.stubsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Stubs_CalculateResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Stubs_CalculateResponse_descriptor, + new java.lang.String[] { "Sum", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressRequestOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressRequestOuterClass.java new file mode 100644 index 000000000..41b0985a2 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressRequestOuterClass.java @@ -0,0 +1,440 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ProgressRequest.proto + +package com.twine.tango.pmr.stubs; + +public final class ProgressRequestOuterClass { + private ProgressRequestOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface ProgressRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Stubs.ProgressRequest) + com.google.protobuf.MessageOrBuilder { + } + /** + * Protobuf type {@code Tango.PMR.Stubs.ProgressRequest} + */ + public static final class ProgressRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Stubs.ProgressRequest) + ProgressRequestOrBuilder { + private static final long serialVersionUID = 0L; + // Use ProgressRequest.newBuilder() to construct. + private ProgressRequest(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ProgressRequest() { + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ProgressRequest( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.internal_static_Tango_PMR_Stubs_ProgressRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.class, com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.Builder.class); + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest)) { + return super.equals(obj); + } + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest other = (com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest) obj; + + boolean result = true; + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Stubs.ProgressRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Stubs.ProgressRequest) + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.internal_static_Tango_PMR_Stubs_ProgressRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.class, com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.Builder.class); + } + + // Construct using com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor; + } + + public com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest getDefaultInstanceForType() { + return com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.getDefaultInstance(); + } + + public com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest build() { + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest buildPartial() { + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest result = new com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest(this); + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest) { + return mergeFrom((com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest other) { + if (other == com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Stubs.ProgressRequest) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Stubs.ProgressRequest) + private static final com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest(); + } + + public static com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public ProgressRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ProgressRequest(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.stubs.ProgressRequestOuterClass.ProgressRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Stubs_ProgressRequest_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\025ProgressRequest.proto\022\017Tango.PMR.Stubs" + + "\"\021\n\017ProgressRequestB\033\n\031com.twine.tango.p" + + "mr.stubsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Stubs_ProgressRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Stubs_ProgressRequest_descriptor, + new java.lang.String[] { }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressResponseOuterClass.java b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressResponseOuterClass.java new file mode 100644 index 000000000..1a14dd2a5 --- /dev/null +++ b/Software/Android_Studio/Tango.PMR/src/main/java/com/twine/tango/pmr/stubs/ProgressResponseOuterClass.java @@ -0,0 +1,507 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ProgressResponse.proto + +package com.twine.tango.pmr.stubs; + +public final class ProgressResponseOuterClass { + private ProgressResponseOuterClass() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface ProgressResponseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Tango.PMR.Stubs.ProgressResponse) + com.google.protobuf.MessageOrBuilder { + + /** + * double Progress = 1; + */ + double getProgress(); + } + /** + * Protobuf type {@code Tango.PMR.Stubs.ProgressResponse} + */ + public static final class ProgressResponse extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Tango.PMR.Stubs.ProgressResponse) + ProgressResponseOrBuilder { + private static final long serialVersionUID = 0L; + // Use ProgressResponse.newBuilder() to construct. + private ProgressResponse(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ProgressResponse() { + progress_ = 0D; + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ProgressResponse( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + case 9: { + + progress_ = input.readDouble(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.internal_static_Tango_PMR_Stubs_ProgressResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.class, com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.Builder.class); + } + + public static final int PROGRESS_FIELD_NUMBER = 1; + private double progress_; + /** + * double Progress = 1; + */ + public double getProgress() { + return progress_; + } + + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (progress_ != 0D) { + output.writeDouble(1, progress_); + } + unknownFields.writeTo(output); + } + + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (progress_ != 0D) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(1, progress_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse)) { + return super.equals(obj); + } + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse other = (com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse) obj; + + boolean result = true; + result = result && ( + java.lang.Double.doubleToLongBits(getProgress()) + == java.lang.Double.doubleToLongBits( + other.getProgress())); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + PROGRESS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getProgress())); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Tango.PMR.Stubs.ProgressResponse} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Tango.PMR.Stubs.ProgressResponse) + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor; + } + + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.internal_static_Tango_PMR_Stubs_ProgressResponse_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.class, com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.Builder.class); + } + + // Construct using com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + public Builder clear() { + super.clear(); + progress_ = 0D; + + return this; + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor; + } + + public com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse getDefaultInstanceForType() { + return com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.getDefaultInstance(); + } + + public com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse build() { + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse buildPartial() { + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse result = new com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse(this); + result.progress_ = progress_; + onBuilt(); + return result; + } + + public Builder clone() { + return (Builder) super.clone(); + } + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.setField(field, value); + } + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return (Builder) super.addRepeatedField(field, value); + } + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse) { + return mergeFrom((com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse other) { + if (other == com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse.getDefaultInstance()) return this; + if (other.getProgress() != 0D) { + setProgress(other.getProgress()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private double progress_ ; + /** + * double Progress = 1; + */ + public double getProgress() { + return progress_; + } + /** + * double Progress = 1; + */ + public Builder setProgress(double value) { + + progress_ = value; + onChanged(); + return this; + } + /** + * double Progress = 1; + */ + public Builder clearProgress() { + + progress_ = 0D; + onChanged(); + return this; + } + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Tango.PMR.Stubs.ProgressResponse) + } + + // @@protoc_insertion_point(class_scope:Tango.PMR.Stubs.ProgressResponse) + private static final com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse(); + } + + public static com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + public ProgressResponse parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ProgressResponse(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + public com.twine.tango.pmr.stubs.ProgressResponseOuterClass.ProgressResponse getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Tango_PMR_Stubs_ProgressResponse_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\026ProgressResponse.proto\022\017Tango.PMR.Stub" + + "s\"$\n\020ProgressResponse\022\020\n\010Progress\030\001 \001(\001B" + + "\033\n\031com.twine.tango.pmr.stubsb\006proto3" + }; + 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; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Tango_PMR_Stubs_ProgressResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Tango_PMR_Stubs_ProgressResponse_descriptor, + new java.lang.String[] { "Progress", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} -- cgit v1.3.1