Add support for Java micro protobuf's to protobuf-2.3.0.
See README.android for additional information.
Change-Id: I6693e405c0d651eacacd3227a876129865dd0d3c
diff --git a/java/README.txt b/java/README.txt
index 3ed06a1..4a2839a 100644
--- a/java/README.txt
+++ b/java/README.txt
@@ -87,6 +87,180 @@
4) Install the classes wherever you prefer.
+Micro version
+============================
+
+The runtime and generated code for MICRO_RUNTIME is smaller
+because it does not include support for the descriptor,
+reflection or extensions. Also, not currently supported
+are packed repeated elements nor testing of java_multiple_files.
+
+To create a jar file for the runtime and run tests invoke
+"mvn package -P micro" from the <protobuf-root>/java
+directory. The generated jar file is
+<protobuf-root>java/target/protobuf-java-2.2.0-micro.jar.
+
+If you wish to compile the MICRO_RUTIME your self, place
+the 7 files below, in <root>/com/google/protobuf and
+create a jar file for use with your code and the generated
+code:
+
+ByteStringMicro.java
+CodedInputStreamMicro.java
+CodedOutputStreamMicro.java
+InvalidProtocolBufferException.java
+MessageMicro.java
+StringUtf8Micro.java
+WireFormatMicro.java
+
+If you wish to change on the code generator it is located
+in /src/google/protobuf/compiler/javamicro.
+
+To generate code for the MICRO_RUNTIME invoke protoc with
+--javamicro_out command line parameter. javamciro_out takes
+a series of optional sub-parameters separated by comma's
+and a final parameter, with a colon separator, which defines
+the source directory. Sub-paraemeters begin with a name
+followed by an equal and if that sub-parameter has multiple
+parameters they are seperated by "|". The command line options
+are:
+
+opt -> speed or space
+java_use_vector -> true or false
+java_package -> <file-name>|<package-name>
+java_outer_classname -> <file-name>|<package-name>
+
+opt:
+ This change the code generation to optimize for speed,
+ opt=speed, or space, opt=space. When opt=speed this
+ changes the code generation for strings to use
+ StringUtf8Micro which eliminates multiple conversions
+ of the string to utf8. The default value is opt=space.
+
+java_use_vector:
+ Is a boolean flag either java_use_vector=true or
+ java_use_vector=false. When java_use_vector=true the
+ code generated for repeated elements uses
+ java.util.Vector and when java_use_vector=false the
+ java.util.ArrayList<> is used. When java.util.Vector
+ is used the code must be compiled with Java 1.3 and
+ when ArrayList is used Java 1.5 or above must be used.
+ The using javac the source parameter maybe used to
+ control the version of the srouce: "javac -source 1.3".
+ You can also change the <source> xml element for the
+ maven-compiler-plugin. Below is for 1.5 sources:
+
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.5</source>
+ <target>1.5</target>
+ </configuration>
+ </plugin>
+
+ When compiling for 1.5 java_use_vector=false or not
+ present where the default value is false.
+
+ And below would be for 1.3 sources note when changing
+ to 1.3 you must also set java_use_vector=true:
+
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.3</source>
+ <target>1.5</target>
+ </configuration>
+ </plugin>
+
+java_package:
+ The allows setting/overriding the java_package option
+ and associates allows a package name for a file to
+ be specified on the command line. Overriding any
+ "option java_package xxxx" in the file. The default
+ if not present is to use the value from the package
+ statment or "option java_package xxxx" in the file.
+
+java_outer_classname:
+ This allows the setting/overriding of the outer
+ class name option and associates a class name
+ to a file. An outer class name is required and
+ must be specified if there are multiple messages
+ in a single proto file either in the proto source
+ file or on the command line. If not present the
+ no outer class name will be used.
+
+Below are a series of examples for clarification of the
+various javamicro_out parameters using
+src/test/proto/simple-data.proto:
+
+package testprotobuf;
+
+message SimpleData {
+ optional fixed64 id = 1;
+ optional string description = 2;
+ optional bool ok = 3 [default = false];
+};
+
+
+Assuming you've only compiled and not installed protoc and
+your current working directory java/, then a simple
+command line to compile simple-data would be:
+
+../src/protoc --javamicro_out=. src/test/proto/simple-data.proto
+
+This will create testprotobuf/SimpleData.java
+
+The directory testprotobuf is created because on line 1
+of simple-data.proto is "package testprotobuf;". If you
+wanted a different package name you could use the
+java_package option command line sub-parameter:
+
+../src/protoc '--javamicro_out=java_package=src/test/proto/simple-data.proto|my_package:.' src/test/proto/simple-data.proto
+
+Here you see the new java_package sub-parameter which
+itself needs two parameters the file name and the
+package name, these are separated by "|". Now you'll
+find my_package/SimpleData.java.
+
+If you wanted to also change the optimization for
+speed you'd add opt=speed with the comma seperator
+as follows:
+
+../src/protoc '--javamicro_out=opt=speed,java_package=src/test/proto/simple-data.proto|my_package:.' src/test/proto/simple-data.proto
+
+Finally if you also wanted an outer class name you'd
+do the following:
+
+../src/protoc '--javamicro_out=opt=speed,java_package=src/test/proto/simple-data.proto|my_package,java_outer_classname=src/test/proto/simple-data.proto|OuterName:.' src/test/proto/simple-data.proto
+
+Now you'll find my_packate/OuterName.java.
+
+As mentioned java_package and java_outer_classname
+may also be specified in the file. In the example
+below we must define java_outer_classname because
+there are multiple messages in
+src/test/proto/two-messages.proto
+
+package testmicroruntime;
+
+option java_package = "com.example";
+option java_outer_classname = "TestMessages";
+
+message TestMessage1 {
+ required int32 id = 1;
+}
+
+message TestMessage2 {
+ required int32 id = 1;
+}
+
+This could be compiled using:
+
+../src/protoc --javamicro_out=. src/test/proto/two-message.proto
+
+With the result will be com/example/TestMessages.java
+
+
Usage
=====
diff --git a/java/pom.xml b/java/pom.xml
index b07f29b..a71a69a 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -96,6 +96,8 @@
<configuration>
<tasks>
<mkdir dir="target/generated-test-sources" />
+ <!--mkdir dir="target/generated-test-sources/opt-space" /-->
+ <!--mkdir dir="target/generated-test-sources/opt-speed" /-->
<exec executable="../src/protoc">
<arg value="--java_out=target/generated-test-sources" />
<arg value="--proto_path=../src" />
@@ -115,8 +117,20 @@
<arg value="../src/google/protobuf/unittest_enormous_descriptor.proto" />
<arg value="../src/google/protobuf/unittest_no_generic_services.proto" />
</exec>
+ <exec executable="../src/protoc">
+ <arg value="--javamicro_out=opt=speed,java_use_vector=false,java_package=google/protobuf/unittest_import_micro.proto|com.google.protobuf.micro,java_outer_classname=google/protobuf/unittest_import_micro.proto|UnittestImportMicro:target/generated-test-sources" />
+ <arg value="--proto_path=../src" />
+ <arg value="--proto_path=src/test/java" />
+ <arg value="../src/google/protobuf/unittest_micro.proto" />
+ <arg value="../src/google/protobuf/unittest_simple_micro.proto" />
+ <arg value="../src/google/protobuf/unittest_stringutf8_micro.proto" />
+ <arg value="../src/google/protobuf/unittest_recursive_micro.proto" />
+ <arg value="../src/google/protobuf/unittest_import_micro.proto" />
+ </exec>
</tasks>
<testSourceRoot>target/generated-test-sources</testSourceRoot>
+ <!--testSourceRoot>target/generated-test-sources/opt-space</testSourceRoot-->
+ <!--testSourceRoot>target/generated-test-sources/opt-speed</testSourceRoot-->
</configuration>
<goals>
<goal>run</goal>
@@ -171,5 +185,48 @@
</plugins>
</build>
</profile>
+ <profile>
+ <id>micro</id>
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <includes>
+ <include>**/MessageMicro.java</include>
+ <include>**/ByteStringMicro.java</include>
+ <include>**/CodedInputStreamMicro.java</include>
+ <include>**/CodedOutputStreamMicro.java</include>
+ <include>**/InvalidProtocolBufferMicroException.java</include>
+ <include>**/StringUtf8Micro.java</include>
+ <include>**/WireFormatMicro.java</include>
+ </includes>
+ <testIncludes>
+ <testInclude>**/MicroTest.java</testInclude>
+ <testInclude>**/MicroOuterClass.java</testInclude>
+ <testInclude>**/SimpleMessageMicro.java</testInclude>
+ <testInclude>**/StringUtf8.java</testInclude>
+ <testInclude>**/RecursiveMessageMicro.java</testInclude>
+ <testInclude>**/UnittestImportMicro.java</testInclude>
+ </testIncludes>
+ </configuration>
+ </plugin>
+ <plugin>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <includes>
+ <include>**/MicroTest.java</include>
+ </includes>
+ </configuration>
+ </plugin>
+ <plugin>
+ <artifactId>maven-jar-plugin</artifactId>
+ <configuration>
+ <classifier>micro</classifier>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
</profiles>
</project>
diff --git a/java/src/main/java/com/google/protobuf/micro/ByteStringMicro.java b/java/src/main/java/com/google/protobuf/micro/ByteStringMicro.java
new file mode 100644
index 0000000..6e87dc9
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/ByteStringMicro.java
@@ -0,0 +1,227 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Immutable array of bytes.
+ *
+ * @author crazybob@google.com Bob Lee
+ * @author kenton@google.com Kenton Varda
+ */
+public final class ByteStringMicro {
+ private final byte[] bytes;
+
+ private ByteStringMicro(final byte[] bytes) {
+ this.bytes = bytes;
+ }
+
+ /**
+ * Gets the byte at the given index.
+ *
+ * @throws ArrayIndexOutOfBoundsException {@code index} is < 0 or >= size
+ */
+ public byte byteAt(final int index) {
+ return bytes[index];
+ }
+
+ /**
+ * Gets the number of bytes.
+ */
+ public int size() {
+ return bytes.length;
+ }
+
+ /**
+ * Returns {@code true} if the size is {@code 0}, {@code false} otherwise.
+ */
+ public boolean isEmpty() {
+ return bytes.length == 0;
+ }
+
+ // =================================================================
+ // byte[] -> ByteStringMicro
+
+ /**
+ * Empty ByteStringMicro.
+ */
+ public static final ByteStringMicro EMPTY = new ByteStringMicro(new byte[0]);
+
+ /**
+ * Copies the given bytes into a {@code ByteStringMicro}.
+ */
+ public static ByteStringMicro copyFrom(final byte[] bytes, final int offset,
+ final int size) {
+ final byte[] copy = new byte[size];
+ System.arraycopy(bytes, offset, copy, 0, size);
+ return new ByteStringMicro(copy);
+ }
+
+ /**
+ * Copies the given bytes into a {@code ByteStringMicro}.
+ */
+ public static ByteStringMicro copyFrom(final byte[] bytes) {
+ return copyFrom(bytes, 0, bytes.length);
+ }
+
+ /**
+ * Encodes {@code text} into a sequence of bytes using the named charset
+ * and returns the result as a {@code ByteStringMicro}.
+ */
+ public static ByteStringMicro copyFrom(final String text, final String charsetName)
+ throws UnsupportedEncodingException {
+ return new ByteStringMicro(text.getBytes(charsetName));
+ }
+
+ /**
+ * Encodes {@code text} into a sequence of UTF-8 bytes and returns the
+ * result as a {@code ByteStringMicro}.
+ */
+ public static ByteStringMicro copyFromUtf8(final String text) {
+ try {
+ return new ByteStringMicro(text.getBytes("UTF-8"));
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException("UTF-8 not supported?");
+ }
+ }
+
+ // =================================================================
+ // ByteStringMicro -> byte[]
+
+ /**
+ * Copies bytes into a buffer at the given offset.
+ *
+ * @param target buffer to copy into
+ * @param offset in the target buffer
+ */
+ public void copyTo(final byte[] target, final int offset) {
+ System.arraycopy(bytes, 0, target, offset, bytes.length);
+ }
+
+ /**
+ * Copies bytes into a buffer.
+ *
+ * @param target buffer to copy into
+ * @param sourceOffset offset within these bytes
+ * @param targetOffset offset within the target buffer
+ * @param size number of bytes to copy
+ */
+ public void copyTo(final byte[] target, final int sourceOffset,
+ final int targetOffset,
+ final int size) {
+ System.arraycopy(bytes, sourceOffset, target, targetOffset, size);
+ }
+
+ /**
+ * Copies bytes to a {@code byte[]}.
+ */
+ public byte[] toByteArray() {
+ final int size = bytes.length;
+ final byte[] copy = new byte[size];
+ System.arraycopy(bytes, 0, copy, 0, size);
+ return copy;
+ }
+
+ /**
+ * Constructs a new {@code String} by decoding the bytes using the
+ * specified charset.
+ */
+ public String toString(final String charsetName)
+ throws UnsupportedEncodingException {
+ return new String(bytes, charsetName);
+ }
+
+ /**
+ * Constructs a new {@code String} by decoding the bytes as UTF-8.
+ */
+ public String toStringUtf8() {
+ try {
+ return new String(bytes, "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException("UTF-8 not supported?");
+ }
+ }
+
+ // =================================================================
+ // equals() and hashCode()
+
+ //@Override for compatibility with Java 1.3 code we can't use annotations
+ public boolean equals(final Object o) {
+ if (o == this) {
+ return true;
+ }
+
+ if (!(o instanceof ByteStringMicro)) {
+ return false;
+ }
+
+ final ByteStringMicro other = (ByteStringMicro) o;
+ final int size = bytes.length;
+ if (size != other.bytes.length) {
+ return false;
+ }
+
+ final byte[] thisBytes = bytes;
+ final byte[] otherBytes = other.bytes;
+ for (int i = 0; i < size; i++) {
+ if (thisBytes[i] != otherBytes[i]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private volatile int hash = 0;
+
+ //@Override for compatibility with Java 1.3 code we can't use annotations
+ public int hashCode() {
+ int h = hash;
+
+ if (h == 0) {
+ final byte[] thisBytes = bytes;
+ final int size = bytes.length;
+
+ h = size;
+ for (int i = 0; i < size; i++) {
+ h = h * 31 + thisBytes[i];
+ }
+ if (h == 0) {
+ h = 1;
+ }
+
+ hash = h;
+ }
+
+ return h;
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/CodedInputStreamMicro.java b/java/src/main/java/com/google/protobuf/micro/CodedInputStreamMicro.java
new file mode 100644
index 0000000..0791b8f
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/CodedInputStreamMicro.java
@@ -0,0 +1,804 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Reads and decodes protocol message fields.
+ *
+ * This class contains two kinds of methods: methods that read specific
+ * protocol message constructs and field types (e.g. {@link #readTag()} and
+ * {@link #readInt32()}) and methods that read low-level values (e.g.
+ * {@link #readRawVarint32()} and {@link #readRawBytes}). If you are reading
+ * encoded protocol messages, you should use the former methods, but if you are
+ * reading some other format of your own design, use the latter.
+ *
+ * @author kenton@google.com Kenton Varda
+ */
+public final class CodedInputStreamMicro {
+ /**
+ * Create a new CodedInputStream wrapping the given InputStream.
+ */
+ public static CodedInputStreamMicro newInstance(final InputStream input) {
+ return new CodedInputStreamMicro(input);
+ }
+
+ /**
+ * Create a new CodedInputStream wrapping the given byte array.
+ */
+ public static CodedInputStreamMicro newInstance(final byte[] buf) {
+ return newInstance(buf, 0, buf.length);
+ }
+
+ /**
+ * Create a new CodedInputStream wrapping the given byte array slice.
+ */
+ public static CodedInputStreamMicro newInstance(final byte[] buf, final int off,
+ final int len) {
+ return new CodedInputStreamMicro(buf, off, len);
+ }
+
+ // -----------------------------------------------------------------
+
+ /**
+ * Attempt to read a field tag, returning zero if we have reached EOF.
+ * Protocol message parsers use this to read tags, since a protocol message
+ * may legally end wherever a tag occurs, and zero is not a valid tag number.
+ */
+ public int readTag() throws IOException {
+ if (isAtEnd()) {
+ lastTag = 0;
+ return 0;
+ }
+
+ lastTag = readRawVarint32();
+ if (lastTag == 0) {
+ // If we actually read zero, that's not a valid tag.
+ throw InvalidProtocolBufferMicroException.invalidTag();
+ }
+ return lastTag;
+ }
+
+ /**
+ * Verifies that the last call to readTag() returned the given tag value.
+ * This is used to verify that a nested group ended with the correct
+ * end tag.
+ *
+ * @throws InvalidProtocolBufferMicroException {@code value} does not match the
+ * last tag.
+ */
+ public void checkLastTagWas(final int value)
+ throws InvalidProtocolBufferMicroException {
+ if (lastTag != value) {
+ throw InvalidProtocolBufferMicroException.invalidEndTag();
+ }
+ }
+
+ /**
+ * Reads and discards a single field, given its tag value.
+ *
+ * @return {@code false} if the tag is an endgroup tag, in which case
+ * nothing is skipped. Otherwise, returns {@code true}.
+ */
+ public boolean skipField(final int tag) throws IOException {
+ switch (WireFormatMicro.getTagWireType(tag)) {
+ case WireFormatMicro.WIRETYPE_VARINT:
+ readInt32();
+ return true;
+ case WireFormatMicro.WIRETYPE_FIXED64:
+ readRawLittleEndian64();
+ return true;
+ case WireFormatMicro.WIRETYPE_LENGTH_DELIMITED:
+ skipRawBytes(readRawVarint32());
+ return true;
+ case WireFormatMicro.WIRETYPE_START_GROUP:
+ skipMessage();
+ checkLastTagWas(
+ WireFormatMicro.makeTag(WireFormatMicro.getTagFieldNumber(tag),
+ WireFormatMicro.WIRETYPE_END_GROUP));
+ return true;
+ case WireFormatMicro.WIRETYPE_END_GROUP:
+ return false;
+ case WireFormatMicro.WIRETYPE_FIXED32:
+ readRawLittleEndian32();
+ return true;
+ default:
+ throw InvalidProtocolBufferMicroException.invalidWireType();
+ }
+ }
+
+ /**
+ * Reads and discards an entire message. This will read either until EOF
+ * or until an endgroup tag, whichever comes first.
+ */
+ public void skipMessage() throws IOException {
+ while (true) {
+ final int tag = readTag();
+ if (tag == 0 || !skipField(tag)) {
+ return;
+ }
+ }
+ }
+
+ // -----------------------------------------------------------------
+
+ /** Read a {@code double} field value from the stream. */
+ public double readDouble() throws IOException {
+ return Double.longBitsToDouble(readRawLittleEndian64());
+ }
+
+ /** Read a {@code float} field value from the stream. */
+ public float readFloat() throws IOException {
+ return Float.intBitsToFloat(readRawLittleEndian32());
+ }
+
+ /** Read a {@code uint64} field value from the stream. */
+ public long readUInt64() throws IOException {
+ return readRawVarint64();
+ }
+
+ /** Read an {@code int64} field value from the stream. */
+ public long readInt64() throws IOException {
+ return readRawVarint64();
+ }
+
+ /** Read an {@code int32} field value from the stream. */
+ public int readInt32() throws IOException {
+ return readRawVarint32();
+ }
+
+ /** Read a {@code fixed64} field value from the stream. */
+ public long readFixed64() throws IOException {
+ return readRawLittleEndian64();
+ }
+
+ /** Read a {@code fixed32} field value from the stream. */
+ public int readFixed32() throws IOException {
+ return readRawLittleEndian32();
+ }
+
+ /** Read a {@code bool} field value from the stream. */
+ public boolean readBool() throws IOException {
+ return readRawVarint32() != 0;
+ }
+
+ /** Read a {@code string} field value from the stream. */
+ public String readString() throws IOException {
+ final int size = readRawVarint32();
+ if (size <= (bufferSize - bufferPos) && size > 0) {
+ // Fast path: We already have the bytes in a contiguous buffer, so
+ // just copy directly from it.
+ final String result = new String(buffer, bufferPos, size, "UTF-8");
+ bufferPos += size;
+ return result;
+ } else {
+ // Slow path: Build a byte array first then copy it.
+ return new String(readRawBytes(size), "UTF-8");
+ }
+ }
+
+ /** Read a {@code group} field value from the stream. */
+ public void readGroup(final MessageMicro msg, final int fieldNumber)
+ throws IOException {
+ if (recursionDepth >= recursionLimit) {
+ throw InvalidProtocolBufferMicroException.recursionLimitExceeded();
+ }
+ ++recursionDepth;
+ msg.mergeFrom(this);
+ checkLastTagWas(
+ WireFormatMicro.makeTag(fieldNumber, WireFormatMicro.WIRETYPE_END_GROUP));
+ --recursionDepth;
+ }
+
+ public void readMessage(final MessageMicro msg)
+ throws IOException {
+ final int length = readRawVarint32();
+ if (recursionDepth >= recursionLimit) {
+ throw InvalidProtocolBufferMicroException.recursionLimitExceeded();
+ }
+ final int oldLimit = pushLimit(length);
+ ++recursionDepth;
+ msg.mergeFrom(this);
+ checkLastTagWas(0);
+ --recursionDepth;
+ popLimit(oldLimit);
+ }
+
+ /** Read a {@code bytes} field value from the stream. */
+ public ByteStringMicro readBytes() throws IOException {
+ final int size = readRawVarint32();
+ if (size <= (bufferSize - bufferPos) && size > 0) {
+ // Fast path: We already have the bytes in a contiguous buffer, so
+ // just copy directly from it.
+ final ByteStringMicro result = ByteStringMicro.copyFrom(buffer, bufferPos, size);
+ bufferPos += size;
+ return result;
+ } else {
+ // Slow path: Build a byte array first then copy it.
+ return ByteStringMicro.copyFrom(readRawBytes(size));
+ }
+ }
+
+ /** Read a {@code uint32} field value from the stream. */
+ public int readUInt32() throws IOException {
+ return readRawVarint32();
+ }
+
+ /**
+ * Read an enum field value from the stream. Caller is responsible
+ * for converting the numeric value to an actual enum.
+ */
+ public int readEnum() throws IOException {
+ return readRawVarint32();
+ }
+
+ /** Read an {@code sfixed32} field value from the stream. */
+ public int readSFixed32() throws IOException {
+ return readRawLittleEndian32();
+ }
+
+ /** Read an {@code sfixed64} field value from the stream. */
+ public long readSFixed64() throws IOException {
+ return readRawLittleEndian64();
+ }
+
+ /** Read an {@code sint32} field value from the stream. */
+ public int readSInt32() throws IOException {
+ return decodeZigZag32(readRawVarint32());
+ }
+
+ /** Read an {@code sint64} field value from the stream. */
+ public long readSInt64() throws IOException {
+ return decodeZigZag64(readRawVarint64());
+ }
+
+ // =================================================================
+
+ /**
+ * Read a raw Varint from the stream. If larger than 32 bits, discard the
+ * upper bits.
+ */
+ public int readRawVarint32() throws IOException {
+ byte tmp = readRawByte();
+ if (tmp >= 0) {
+ return tmp;
+ }
+ int result = tmp & 0x7f;
+ if ((tmp = readRawByte()) >= 0) {
+ result |= tmp << 7;
+ } else {
+ result |= (tmp & 0x7f) << 7;
+ if ((tmp = readRawByte()) >= 0) {
+ result |= tmp << 14;
+ } else {
+ result |= (tmp & 0x7f) << 14;
+ if ((tmp = readRawByte()) >= 0) {
+ result |= tmp << 21;
+ } else {
+ result |= (tmp & 0x7f) << 21;
+ result |= (tmp = readRawByte()) << 28;
+ if (tmp < 0) {
+ // Discard upper 32 bits.
+ for (int i = 0; i < 5; i++) {
+ if (readRawByte() >= 0) {
+ return result;
+ }
+ }
+ throw InvalidProtocolBufferMicroException.malformedVarint();
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Reads a varint from the input one byte at a time, so that it does not
+ * read any bytes after the end of the varint. If you simply wrapped the
+ * stream in a CodedInputStream and used {@link #readRawVarint32(InputStream)}
+ * then you would probably end up reading past the end of the varint since
+ * CodedInputStream buffers its input.
+ */
+ static int readRawVarint32(final InputStream input) throws IOException {
+ int result = 0;
+ int offset = 0;
+ for (; offset < 32; offset += 7) {
+ final int b = input.read();
+ if (b == -1) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+ result |= (b & 0x7f) << offset;
+ if ((b & 0x80) == 0) {
+ return result;
+ }
+ }
+ // Keep reading up to 64 bits.
+ for (; offset < 64; offset += 7) {
+ final int b = input.read();
+ if (b == -1) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+ if ((b & 0x80) == 0) {
+ return result;
+ }
+ }
+ throw InvalidProtocolBufferMicroException.malformedVarint();
+ }
+
+ /** Read a raw Varint from the stream. */
+ public long readRawVarint64() throws IOException {
+ int shift = 0;
+ long result = 0;
+ while (shift < 64) {
+ final byte b = readRawByte();
+ result |= (long)(b & 0x7F) << shift;
+ if ((b & 0x80) == 0) {
+ return result;
+ }
+ shift += 7;
+ }
+ throw InvalidProtocolBufferMicroException.malformedVarint();
+ }
+
+ /** Read a 32-bit little-endian integer from the stream. */
+ public int readRawLittleEndian32() throws IOException {
+ final byte b1 = readRawByte();
+ final byte b2 = readRawByte();
+ final byte b3 = readRawByte();
+ final byte b4 = readRawByte();
+ return ((b1 & 0xff) ) |
+ ((b2 & 0xff) << 8) |
+ ((b3 & 0xff) << 16) |
+ ((b4 & 0xff) << 24);
+ }
+
+ /** Read a 64-bit little-endian integer from the stream. */
+ public long readRawLittleEndian64() throws IOException {
+ final byte b1 = readRawByte();
+ final byte b2 = readRawByte();
+ final byte b3 = readRawByte();
+ final byte b4 = readRawByte();
+ final byte b5 = readRawByte();
+ final byte b6 = readRawByte();
+ final byte b7 = readRawByte();
+ final byte b8 = readRawByte();
+ return (((long)b1 & 0xff) ) |
+ (((long)b2 & 0xff) << 8) |
+ (((long)b3 & 0xff) << 16) |
+ (((long)b4 & 0xff) << 24) |
+ (((long)b5 & 0xff) << 32) |
+ (((long)b6 & 0xff) << 40) |
+ (((long)b7 & 0xff) << 48) |
+ (((long)b8 & 0xff) << 56);
+ }
+
+ /**
+ * Decode a ZigZag-encoded 32-bit value. ZigZag encodes signed integers
+ * into values that can be efficiently encoded with varint. (Otherwise,
+ * negative values must be sign-extended to 64 bits to be varint encoded,
+ * thus always taking 10 bytes on the wire.)
+ *
+ * @param n An unsigned 32-bit integer, stored in a signed int because
+ * Java has no explicit unsigned support.
+ * @return A signed 32-bit integer.
+ */
+ public static int decodeZigZag32(final int n) {
+ return (n >>> 1) ^ -(n & 1);
+ }
+
+ /**
+ * Decode a ZigZag-encoded 64-bit value. ZigZag encodes signed integers
+ * into values that can be efficiently encoded with varint. (Otherwise,
+ * negative values must be sign-extended to 64 bits to be varint encoded,
+ * thus always taking 10 bytes on the wire.)
+ *
+ * @param n An unsigned 64-bit integer, stored in a signed int because
+ * Java has no explicit unsigned support.
+ * @return A signed 64-bit integer.
+ */
+ public static long decodeZigZag64(final long n) {
+ return (n >>> 1) ^ -(n & 1);
+ }
+
+ // -----------------------------------------------------------------
+
+ private final byte[] buffer;
+ private int bufferSize;
+ private int bufferSizeAfterLimit;
+ private int bufferPos;
+ private final InputStream input;
+ private int lastTag;
+
+ /**
+ * The total number of bytes read before the current buffer. The total
+ * bytes read up to the current position can be computed as
+ * {@code totalBytesRetired + bufferPos}.
+ */
+ private int totalBytesRetired;
+
+ /** The absolute position of the end of the current message. */
+ private int currentLimit = Integer.MAX_VALUE;
+
+ /** See setRecursionLimit() */
+ private int recursionDepth;
+ private int recursionLimit = DEFAULT_RECURSION_LIMIT;
+
+ /** See setSizeLimit() */
+ private int sizeLimit = DEFAULT_SIZE_LIMIT;
+
+ private static final int DEFAULT_RECURSION_LIMIT = 64;
+ private static final int DEFAULT_SIZE_LIMIT = 64 << 20; // 64MB
+ private static final int BUFFER_SIZE = 4096;
+
+ private CodedInputStreamMicro(final byte[] buffer, final int off, final int len) {
+ this.buffer = buffer;
+ bufferSize = off + len;
+ bufferPos = off;
+ input = null;
+ }
+
+ private CodedInputStreamMicro(final InputStream input) {
+ buffer = new byte[BUFFER_SIZE];
+ bufferSize = 0;
+ bufferPos = 0;
+ this.input = input;
+ }
+
+ /**
+ * Set the maximum message recursion depth. In order to prevent malicious
+ * messages from causing stack overflows, {@code CodedInputStream} limits
+ * how deeply messages may be nested. The default limit is 64.
+ *
+ * @return the old limit.
+ */
+ public int setRecursionLimit(final int limit) {
+ if (limit < 0) {
+ throw new IllegalArgumentException(
+ "Recursion limit cannot be negative: " + limit);
+ }
+ final int oldLimit = recursionLimit;
+ recursionLimit = limit;
+ return oldLimit;
+ }
+
+ /**
+ * Set the maximum message size. In order to prevent malicious
+ * messages from exhausting memory or causing integer overflows,
+ * {@code CodedInputStream} limits how large a message may be.
+ * The default limit is 64MB. You should set this limit as small
+ * as you can without harming your app's functionality. Note that
+ * size limits only apply when reading from an {@code InputStream}, not
+ * when constructed around a raw byte array (nor with
+ * {@link ByteStringMicro#newCodedInput}).
+ * <p>
+ * If you want to read several messages from a single CodedInputStream, you
+ * could call {@link #resetSizeCounter()} after each one to avoid hitting the
+ * size limit.
+ *
+ * @return the old limit.
+ */
+ public int setSizeLimit(final int limit) {
+ if (limit < 0) {
+ throw new IllegalArgumentException(
+ "Size limit cannot be negative: " + limit);
+ }
+ final int oldLimit = sizeLimit;
+ sizeLimit = limit;
+ return oldLimit;
+ }
+
+ /**
+ * Resets the current size counter to zero (see {@link #setSizeLimit(int)}).
+ */
+ public void resetSizeCounter() {
+ totalBytesRetired = 0;
+ }
+
+ /**
+ * Sets {@code currentLimit} to (current position) + {@code byteLimit}. This
+ * is called when descending into a length-delimited embedded message.
+ *
+ * @return the old limit.
+ */
+ public int pushLimit(int byteLimit) throws InvalidProtocolBufferMicroException {
+ if (byteLimit < 0) {
+ throw InvalidProtocolBufferMicroException.negativeSize();
+ }
+ byteLimit += totalBytesRetired + bufferPos;
+ final int oldLimit = currentLimit;
+ if (byteLimit > oldLimit) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+ currentLimit = byteLimit;
+
+ recomputeBufferSizeAfterLimit();
+
+ return oldLimit;
+ }
+
+ private void recomputeBufferSizeAfterLimit() {
+ bufferSize += bufferSizeAfterLimit;
+ final int bufferEnd = totalBytesRetired + bufferSize;
+ if (bufferEnd > currentLimit) {
+ // Limit is in current buffer.
+ bufferSizeAfterLimit = bufferEnd - currentLimit;
+ bufferSize -= bufferSizeAfterLimit;
+ } else {
+ bufferSizeAfterLimit = 0;
+ }
+ }
+
+ /**
+ * Discards the current limit, returning to the previous limit.
+ *
+ * @param oldLimit The old limit, as returned by {@code pushLimit}.
+ */
+ public void popLimit(final int oldLimit) {
+ currentLimit = oldLimit;
+ recomputeBufferSizeAfterLimit();
+ }
+
+ /**
+ * Returns the number of bytes to be read before the current limit.
+ * If no limit is set, returns -1.
+ */
+ public int getBytesUntilLimit() {
+ if (currentLimit == Integer.MAX_VALUE) {
+ return -1;
+ }
+
+ final int currentAbsolutePosition = totalBytesRetired + bufferPos;
+ return currentLimit - currentAbsolutePosition;
+ }
+
+ /**
+ * Returns true if the stream has reached the end of the input. This is the
+ * case if either the end of the underlying input source has been reached or
+ * if the stream has reached a limit created using {@link #pushLimit(int)}.
+ */
+ public boolean isAtEnd() throws IOException {
+ return bufferPos == bufferSize && !refillBuffer(false);
+ }
+
+ /**
+ * Called with {@code this.buffer} is empty to read more bytes from the
+ * input. If {@code mustSucceed} is true, refillBuffer() gurantees that
+ * either there will be at least one byte in the buffer when it returns
+ * or it will throw an exception. If {@code mustSucceed} is false,
+ * refillBuffer() returns false if no more bytes were available.
+ */
+ private boolean refillBuffer(final boolean mustSucceed) throws IOException {
+ if (bufferPos < bufferSize) {
+ throw new IllegalStateException(
+ "refillBuffer() called when buffer wasn't empty.");
+ }
+
+ if (totalBytesRetired + bufferSize == currentLimit) {
+ // Oops, we hit a limit.
+ if (mustSucceed) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ } else {
+ return false;
+ }
+ }
+
+ totalBytesRetired += bufferSize;
+
+ bufferPos = 0;
+ bufferSize = (input == null) ? -1 : input.read(buffer);
+ if (bufferSize == 0 || bufferSize < -1) {
+ throw new IllegalStateException(
+ "InputStream#read(byte[]) returned invalid result: " + bufferSize +
+ "\nThe InputStream implementation is buggy.");
+ }
+ if (bufferSize == -1) {
+ bufferSize = 0;
+ if (mustSucceed) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ } else {
+ return false;
+ }
+ } else {
+ recomputeBufferSizeAfterLimit();
+ final int totalBytesRead =
+ totalBytesRetired + bufferSize + bufferSizeAfterLimit;
+ if (totalBytesRead > sizeLimit || totalBytesRead < 0) {
+ throw InvalidProtocolBufferMicroException.sizeLimitExceeded();
+ }
+ return true;
+ }
+ }
+
+ /**
+ * Read one byte from the input.
+ *
+ * @throws InvalidProtocolBufferMicroException The end of the stream or the current
+ * limit was reached.
+ */
+ public byte readRawByte() throws IOException {
+ if (bufferPos == bufferSize) {
+ refillBuffer(true);
+ }
+ return buffer[bufferPos++];
+ }
+
+ /**
+ * Read a fixed size of bytes from the input.
+ *
+ * @throws InvalidProtocolBufferMicroException The end of the stream or the current
+ * limit was reached.
+ */
+ public byte[] readRawBytes(final int size) throws IOException {
+ if (size < 0) {
+ throw InvalidProtocolBufferMicroException.negativeSize();
+ }
+
+ if (totalBytesRetired + bufferPos + size > currentLimit) {
+ // Read to the end of the stream anyway.
+ skipRawBytes(currentLimit - totalBytesRetired - bufferPos);
+ // Then fail.
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+
+ if (size <= bufferSize - bufferPos) {
+ // We have all the bytes we need already.
+ final byte[] bytes = new byte[size];
+ System.arraycopy(buffer, bufferPos, bytes, 0, size);
+ bufferPos += size;
+ return bytes;
+ } else if (size < BUFFER_SIZE) {
+ // Reading more bytes than are in the buffer, but not an excessive number
+ // of bytes. We can safely allocate the resulting array ahead of time.
+
+ // First copy what we have.
+ final byte[] bytes = new byte[size];
+ int pos = bufferSize - bufferPos;
+ System.arraycopy(buffer, bufferPos, bytes, 0, pos);
+ bufferPos = bufferSize;
+
+ // We want to use refillBuffer() and then copy from the buffer into our
+ // byte array rather than reading directly into our byte array because
+ // the input may be unbuffered.
+ refillBuffer(true);
+
+ while (size - pos > bufferSize) {
+ System.arraycopy(buffer, 0, bytes, pos, bufferSize);
+ pos += bufferSize;
+ bufferPos = bufferSize;
+ refillBuffer(true);
+ }
+
+ System.arraycopy(buffer, 0, bytes, pos, size - pos);
+ bufferPos = size - pos;
+
+ return bytes;
+ } else {
+ // The size is very large. For security reasons, we can't allocate the
+ // entire byte array yet. The size comes directly from the input, so a
+ // maliciously-crafted message could provide a bogus very large size in
+ // order to trick the app into allocating a lot of memory. We avoid this
+ // by allocating and reading only a small chunk at a time, so that the
+ // malicious message must actually *be* extremely large to cause
+ // problems. Meanwhile, we limit the allowed size of a message elsewhere.
+
+ // Remember the buffer markers since we'll have to copy the bytes out of
+ // it later.
+ final int originalBufferPos = bufferPos;
+ final int originalBufferSize = bufferSize;
+
+ // Mark the current buffer consumed.
+ totalBytesRetired += bufferSize;
+ bufferPos = 0;
+ bufferSize = 0;
+
+ // Read all the rest of the bytes we need.
+ int sizeLeft = size - (originalBufferSize - originalBufferPos);
+
+ // For compatibility with Java 1.3 use Vector
+ final java.util.Vector chunks = new java.util.Vector();
+
+ while (sizeLeft > 0) {
+ final byte[] chunk = new byte[Math.min(sizeLeft, BUFFER_SIZE)];
+ int pos = 0;
+ while (pos < chunk.length) {
+ final int n = (input == null) ? -1 :
+ input.read(chunk, pos, chunk.length - pos);
+ if (n == -1) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+ totalBytesRetired += n;
+ pos += n;
+ }
+ sizeLeft -= chunk.length;
+ chunks.addElement(chunk);
+ }
+
+ // OK, got everything. Now concatenate it all into one buffer.
+ final byte[] bytes = new byte[size];
+
+ // Start by copying the leftover bytes from this.buffer.
+ int pos = originalBufferSize - originalBufferPos;
+ System.arraycopy(buffer, originalBufferPos, bytes, 0, pos);
+
+ // And now all the chunks.
+ for (int i = 0; i < chunks.size(); i++) {
+ byte [] chunk = (byte [])chunks.elementAt(i);
+ System.arraycopy(chunk, 0, bytes, pos, chunk.length);
+ pos += chunk.length;
+ }
+
+ // Done.
+ return bytes;
+ }
+ }
+
+ /**
+ * Reads and discards {@code size} bytes.
+ *
+ * @throws InvalidProtocolBufferMicroException The end of the stream or the current
+ * limit was reached.
+ */
+ public void skipRawBytes(final int size) throws IOException {
+ if (size < 0) {
+ throw InvalidProtocolBufferMicroException.negativeSize();
+ }
+
+ if (totalBytesRetired + bufferPos + size > currentLimit) {
+ // Read to the end of the stream anyway.
+ skipRawBytes(currentLimit - totalBytesRetired - bufferPos);
+ // Then fail.
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+
+ if (size <= bufferSize - bufferPos) {
+ // We have all the bytes we need already.
+ bufferPos += size;
+ } else {
+ // Skipping more bytes than are in the buffer. First skip what we have.
+ int pos = bufferSize - bufferPos;
+ totalBytesRetired += pos;
+ bufferPos = 0;
+ bufferSize = 0;
+
+ // Then skip directly from the InputStream for the rest.
+ while (pos < size) {
+ final int n = (input == null) ? -1 : (int) input.skip(size - pos);
+ if (n <= 0) {
+ throw InvalidProtocolBufferMicroException.truncatedMessage();
+ }
+ pos += n;
+ totalBytesRetired += n;
+ }
+ }
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/CodedOutputStreamMicro.java b/java/src/main/java/com/google/protobuf/micro/CodedOutputStreamMicro.java
new file mode 100644
index 0000000..68b6e97
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/CodedOutputStreamMicro.java
@@ -0,0 +1,996 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Encodes and writes protocol message fields.
+ *
+ * <p>This class contains two kinds of methods: methods that write specific
+ * protocol message constructs and field types (e.g. {@link #writeTag} and
+ * {@link #writeInt32}) and methods that write low-level values (e.g.
+ * {@link #writeRawVarint32} and {@link #writeRawBytes}). If you are
+ * writing encoded protocol messages, you should use the former methods, but if
+ * you are writing some other format of your own design, use the latter.
+ *
+ * <p>This class is totally unsynchronized.
+ *
+ * @author kneton@google.com Kenton Varda
+ */
+public final class CodedOutputStreamMicro {
+ private final byte[] buffer;
+ private final int limit;
+ private int position;
+
+ private final OutputStream output;
+
+ /**
+ * The buffer size used in {@link #newInstance(OutputStream)}.
+ */
+ public static final int DEFAULT_BUFFER_SIZE = 4096;
+
+ private CodedOutputStreamMicro(final byte[] buffer, final int offset,
+ final int length) {
+ output = null;
+ this.buffer = buffer;
+ position = offset;
+ limit = offset + length;
+ }
+
+ private CodedOutputStreamMicro(final OutputStream output, final byte[] buffer) {
+ this.output = output;
+ this.buffer = buffer;
+ position = 0;
+ limit = buffer.length;
+ }
+
+ /**
+ * Create a new {@code CodedOutputStream} wrapping the given
+ * {@code OutputStream}.
+ */
+ public static CodedOutputStreamMicro newInstance(final OutputStream output) {
+ return newInstance(output, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Create a new {@code CodedOutputStream} wrapping the given
+ * {@code OutputStream} with a given buffer size.
+ */
+ public static CodedOutputStreamMicro newInstance(final OutputStream output,
+ final int bufferSize) {
+ return new CodedOutputStreamMicro(output, new byte[bufferSize]);
+ }
+
+ /**
+ * Create a new {@code CodedOutputStream} that writes directly to the given
+ * byte array. If more bytes are written than fit in the array,
+ * {@link OutOfSpaceException} will be thrown. Writing directly to a flat
+ * array is faster than writing to an {@code OutputStream}.
+ */
+ public static CodedOutputStreamMicro newInstance(final byte[] flatArray) {
+ return newInstance(flatArray, 0, flatArray.length);
+ }
+
+ /**
+ * Create a new {@code CodedOutputStream} that writes directly to the given
+ * byte array slice. If more bytes are written than fit in the slice,
+ * {@link OutOfSpaceException} will be thrown. Writing directly to a flat
+ * array is faster than writing to an {@code OutputStream}.
+ */
+ public static CodedOutputStreamMicro newInstance(final byte[] flatArray,
+ final int offset,
+ final int length) {
+ return new CodedOutputStreamMicro(flatArray, offset, length);
+ }
+
+ // -----------------------------------------------------------------
+
+ /** Write a {@code double} field, including tag, to the stream. */
+ public void writeDouble(final int fieldNumber, final double value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED64);
+ writeDoubleNoTag(value);
+ }
+
+ /** Write a {@code float} field, including tag, to the stream. */
+ public void writeFloat(final int fieldNumber, final float value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED32);
+ writeFloatNoTag(value);
+ }
+
+ /** Write a {@code uint64} field, including tag, to the stream. */
+ public void writeUInt64(final int fieldNumber, final long value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeUInt64NoTag(value);
+ }
+
+ /** Write an {@code int64} field, including tag, to the stream. */
+ public void writeInt64(final int fieldNumber, final long value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeInt64NoTag(value);
+ }
+
+ /** Write an {@code int32} field, including tag, to the stream. */
+ public void writeInt32(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeInt32NoTag(value);
+ }
+
+ /** Write a {@code fixed64} field, including tag, to the stream. */
+ public void writeFixed64(final int fieldNumber, final long value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED64);
+ writeFixed64NoTag(value);
+ }
+
+ /** Write a {@code fixed32} field, including tag, to the stream. */
+ public void writeFixed32(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED32);
+ writeFixed32NoTag(value);
+ }
+
+ /** Write a {@code bool} field, including tag, to the stream. */
+ public void writeBool(final int fieldNumber, final boolean value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeBoolNoTag(value);
+ }
+
+ /** Write a {@code string} field, including tag, to the stream. */
+ public void writeString(final int fieldNumber, final String value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_LENGTH_DELIMITED);
+ writeStringNoTag(value);
+ }
+
+ /** Write a {@code StringUtf8Micro} field, including tag, to the stream. */
+ public void writeStringUtf8(final int fieldNumber, final StringUtf8Micro value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_LENGTH_DELIMITED);
+ writeStringUtf8NoTag(value);
+ }
+
+ /** Write a {@code group} field, including tag, to the stream. */
+ public void writeGroup(final int fieldNumber, final MessageMicro value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_START_GROUP);
+ writeGroupNoTag(value);
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_END_GROUP);
+ }
+
+ /** Write an embedded message field, including tag, to the stream. */
+ public void writeMessage(final int fieldNumber, final MessageMicro value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_LENGTH_DELIMITED);
+ writeMessageNoTag(value);
+ }
+
+ /** Write a {@code bytes} field, including tag, to the stream. */
+ public void writeBytes(final int fieldNumber, final ByteStringMicro value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_LENGTH_DELIMITED);
+ writeBytesNoTag(value);
+ }
+
+ /** Write a {@code uint32} field, including tag, to the stream. */
+ public void writeUInt32(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeUInt32NoTag(value);
+ }
+
+ /**
+ * Write an enum field, including tag, to the stream. Caller is responsible
+ * for converting the enum value to its numeric value.
+ */
+ public void writeEnum(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeEnumNoTag(value);
+ }
+
+ /** Write an {@code sfixed32} field, including tag, to the stream. */
+ public void writeSFixed32(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED32);
+ writeSFixed32NoTag(value);
+ }
+
+ /** Write an {@code sfixed64} field, including tag, to the stream. */
+ public void writeSFixed64(final int fieldNumber, final long value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_FIXED64);
+ writeSFixed64NoTag(value);
+ }
+
+ /** Write an {@code sint32} field, including tag, to the stream. */
+ public void writeSInt32(final int fieldNumber, final int value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeSInt32NoTag(value);
+ }
+
+ /** Write an {@code sint64} field, including tag, to the stream. */
+ public void writeSInt64(final int fieldNumber, final long value)
+ throws IOException {
+ writeTag(fieldNumber, WireFormatMicro.WIRETYPE_VARINT);
+ writeSInt64NoTag(value);
+ }
+
+ /**
+ * Write a MessageSet extension field to the stream. For historical reasons,
+ * the wire format differs from normal fields.
+ */
+// public void writeMessageSetExtension(final int fieldNumber,
+// final MessageMicro value)
+// throws IOException {
+// writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_START_GROUP);
+// writeUInt32(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber);
+// writeMessage(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
+// writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_END_GROUP);
+// }
+
+ /**
+ * Write an unparsed MessageSet extension field to the stream. For
+ * historical reasons, the wire format differs from normal fields.
+ */
+// public void writeRawMessageSetExtension(final int fieldNumber,
+// final ByteStringMicro value)
+// throws IOException {
+// writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_START_GROUP);
+// writeUInt32(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber);
+// writeBytes(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
+// writeTag(WireFormatMicro.MESSAGE_SET_ITEM, WireFormatMicro.WIRETYPE_END_GROUP);
+// }
+
+ // -----------------------------------------------------------------
+
+ /** Write a {@code double} field to the stream. */
+ public void writeDoubleNoTag(final double value) throws IOException {
+ writeRawLittleEndian64(Double.doubleToLongBits(value));
+ }
+
+ /** Write a {@code float} field to the stream. */
+ public void writeFloatNoTag(final float value) throws IOException {
+ writeRawLittleEndian32(Float.floatToIntBits(value));
+ }
+
+ /** Write a {@code uint64} field to the stream. */
+ public void writeUInt64NoTag(final long value) throws IOException {
+ writeRawVarint64(value);
+ }
+
+ /** Write an {@code int64} field to the stream. */
+ public void writeInt64NoTag(final long value) throws IOException {
+ writeRawVarint64(value);
+ }
+
+ /** Write an {@code int32} field to the stream. */
+ public void writeInt32NoTag(final int value) throws IOException {
+ if (value >= 0) {
+ writeRawVarint32(value);
+ } else {
+ // Must sign-extend.
+ writeRawVarint64(value);
+ }
+ }
+
+ /** Write a {@code fixed64} field to the stream. */
+ public void writeFixed64NoTag(final long value) throws IOException {
+ writeRawLittleEndian64(value);
+ }
+
+ /** Write a {@code fixed32} field to the stream. */
+ public void writeFixed32NoTag(final int value) throws IOException {
+ writeRawLittleEndian32(value);
+ }
+
+ /** Write a {@code bool} field to the stream. */
+ public void writeBoolNoTag(final boolean value) throws IOException {
+ writeRawByte(value ? 1 : 0);
+ }
+
+ /** Write a {@code string} field to the stream. */
+ public void writeStringNoTag(final String value) throws IOException {
+ // Unfortunately there does not appear to be any way to tell Java to encode
+ // UTF-8 directly into our buffer, so we have to let it create its own byte
+ // array and then copy.
+ final byte[] bytes = value.getBytes("UTF-8");
+ writeRawVarint32(bytes.length);
+ writeRawBytes(bytes);
+ }
+
+ /** Write a {@code StringUtf8Micro} field to the stream. */
+ public void writeStringUtf8NoTag(final StringUtf8Micro value) throws IOException {
+ final byte[] bytes = value.getBytes();
+ writeRawVarint32(bytes.length);
+ writeRawBytes(bytes);
+ }
+
+ /** Write a {@code group} field to the stream. */
+ public void writeGroupNoTag(final MessageMicro value) throws IOException {
+ value.writeTo(this);
+ }
+
+ /** Write an embedded message field to the stream. */
+ public void writeMessageNoTag(final MessageMicro value) throws IOException {
+ writeRawVarint32(value.getCachedSize());
+ value.writeTo(this);
+ }
+
+ /** Write a {@code bytes} field to the stream. */
+ public void writeBytesNoTag(final ByteStringMicro value) throws IOException {
+ final byte[] bytes = value.toByteArray();
+ writeRawVarint32(bytes.length);
+ writeRawBytes(bytes);
+ }
+
+ /** Write a {@code uint32} field to the stream. */
+ public void writeUInt32NoTag(final int value) throws IOException {
+ writeRawVarint32(value);
+ }
+
+ /**
+ * Write an enum field to the stream. Caller is responsible
+ * for converting the enum value to its numeric value.
+ */
+ public void writeEnumNoTag(final int value) throws IOException {
+ writeRawVarint32(value);
+ }
+
+ /** Write an {@code sfixed32} field to the stream. */
+ public void writeSFixed32NoTag(final int value) throws IOException {
+ writeRawLittleEndian32(value);
+ }
+
+ /** Write an {@code sfixed64} field to the stream. */
+ public void writeSFixed64NoTag(final long value) throws IOException {
+ writeRawLittleEndian64(value);
+ }
+
+ /** Write an {@code sint32} field to the stream. */
+ public void writeSInt32NoTag(final int value) throws IOException {
+ writeRawVarint32(encodeZigZag32(value));
+ }
+
+ /** Write an {@code sint64} field to the stream. */
+ public void writeSInt64NoTag(final long value) throws IOException {
+ writeRawVarint64(encodeZigZag64(value));
+ }
+
+ // =================================================================
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code double} field, including tag.
+ */
+ public static int computeDoubleSize(final int fieldNumber,
+ final double value) {
+ return computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code float} field, including tag.
+ */
+ public static int computeFloatSize(final int fieldNumber, final float value) {
+ return computeTagSize(fieldNumber) + computeFloatSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code uint64} field, including tag.
+ */
+ public static int computeUInt64Size(final int fieldNumber, final long value) {
+ return computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code int64} field, including tag.
+ */
+ public static int computeInt64Size(final int fieldNumber, final long value) {
+ return computeTagSize(fieldNumber) + computeInt64SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code int32} field, including tag.
+ */
+ public static int computeInt32Size(final int fieldNumber, final int value) {
+ return computeTagSize(fieldNumber) + computeInt32SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code fixed64} field, including tag.
+ */
+ public static int computeFixed64Size(final int fieldNumber,
+ final long value) {
+ return computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code fixed32} field, including tag.
+ */
+ public static int computeFixed32Size(final int fieldNumber,
+ final int value) {
+ return computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code bool} field, including tag.
+ */
+ public static int computeBoolSize(final int fieldNumber,
+ final boolean value) {
+ return computeTagSize(fieldNumber) + computeBoolSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code string} field, including tag.
+ */
+ public static int computeStringSize(final int fieldNumber,
+ final String value) {
+ return computeTagSize(fieldNumber) + computeStringSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code StringUtf8Micro} field, including tag.
+ */
+ public static int computeStringUtf8Size(final int fieldNumber,
+ final StringUtf8Micro value) {
+ return computeTagSize(fieldNumber) + computeStringUtf8SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code group} field, including tag.
+ */
+ public static int computeGroupSize(final int fieldNumber,
+ final MessageMicro value) {
+ return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * embedded message field, including tag.
+ */
+ public static int computeMessageSize(final int fieldNumber,
+ final MessageMicro value) {
+ return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code bytes} field, including tag.
+ */
+ public static int computeBytesSize(final int fieldNumber,
+ final ByteStringMicro value) {
+ return computeTagSize(fieldNumber) + computeBytesSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code uint32} field, including tag.
+ */
+ public static int computeUInt32Size(final int fieldNumber, final int value) {
+ return computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * enum field, including tag. Caller is responsible for converting the
+ * enum value to its numeric value.
+ */
+ public static int computeEnumSize(final int fieldNumber, final int value) {
+ return computeTagSize(fieldNumber) + computeEnumSizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sfixed32} field, including tag.
+ */
+ public static int computeSFixed32Size(final int fieldNumber,
+ final int value) {
+ return computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sfixed64} field, including tag.
+ */
+ public static int computeSFixed64Size(final int fieldNumber,
+ final long value) {
+ return computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sint32} field, including tag.
+ */
+ public static int computeSInt32Size(final int fieldNumber, final int value) {
+ return computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sint64} field, including tag.
+ */
+ public static int computeSInt64Size(final int fieldNumber, final long value) {
+ return computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * MessageSet extension to the stream. For historical reasons,
+ * the wire format differs from normal fields.
+ */
+// public static int computeMessageSetExtensionSize(
+// final int fieldNumber, final MessageMicro value) {
+// return computeTagSize(WireFormatMicro.MESSAGE_SET_ITEM) * 2 +
+// computeUInt32Size(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber) +
+// computeMessageSize(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
+// }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * unparsed MessageSet extension field to the stream. For
+ * historical reasons, the wire format differs from normal fields.
+ */
+// public static int computeRawMessageSetExtensionSize(
+// final int fieldNumber, final ByteStringMicro value) {
+// return computeTagSize(WireFormatMicro.MESSAGE_SET_ITEM) * 2 +
+// computeUInt32Size(WireFormatMicro.MESSAGE_SET_TYPE_ID, fieldNumber) +
+// computeBytesSize(WireFormatMicro.MESSAGE_SET_MESSAGE, value);
+// }
+
+ // -----------------------------------------------------------------
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code double} field, including tag.
+ */
+ public static int computeDoubleSizeNoTag(final double value) {
+ return LITTLE_ENDIAN_64_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code float} field, including tag.
+ */
+ public static int computeFloatSizeNoTag(final float value) {
+ return LITTLE_ENDIAN_32_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code uint64} field, including tag.
+ */
+ public static int computeUInt64SizeNoTag(final long value) {
+ return computeRawVarint64Size(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code int64} field, including tag.
+ */
+ public static int computeInt64SizeNoTag(final long value) {
+ return computeRawVarint64Size(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code int32} field, including tag.
+ */
+ public static int computeInt32SizeNoTag(final int value) {
+ if (value >= 0) {
+ return computeRawVarint32Size(value);
+ } else {
+ // Must sign-extend.
+ return 10;
+ }
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code fixed64} field.
+ */
+ public static int computeFixed64SizeNoTag(final long value) {
+ return LITTLE_ENDIAN_64_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code fixed32} field.
+ */
+ public static int computeFixed32SizeNoTag(final int value) {
+ return LITTLE_ENDIAN_32_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code bool} field.
+ */
+ public static int computeBoolSizeNoTag(final boolean value) {
+ return 1;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code string} field.
+ */
+ public static int computeStringSizeNoTag(final String value) {
+ try {
+ final byte[] bytes = value.getBytes("UTF-8");
+ return computeRawVarint32Size(bytes.length) +
+ bytes.length;
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException("UTF-8 not supported.");
+ }
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code StringUtf8Micro} field.
+ */
+ public static int computeStringUtf8SizeNoTag(final StringUtf8Micro value) {
+ final byte[] bytes = value.getBytes();
+ return computeRawVarint32Size(bytes.length) +
+ bytes.length;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code group} field.
+ */
+ public static int computeGroupSizeNoTag(final MessageMicro value) {
+ return value.getCachedSize();
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an embedded
+ * message field.
+ */
+ public static int computeMessageSizeNoTag(final MessageMicro value) {
+ final int size = value.getCachedSize();
+ return computeRawVarint32Size(size) + size;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code bytes} field.
+ */
+ public static int computeBytesSizeNoTag(final ByteStringMicro value) {
+ return computeRawVarint32Size(value.size()) +
+ value.size();
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a
+ * {@code uint32} field.
+ */
+ public static int computeUInt32SizeNoTag(final int value) {
+ return computeRawVarint32Size(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an enum field.
+ * Caller is responsible for converting the enum value to its numeric value.
+ */
+ public static int computeEnumSizeNoTag(final int value) {
+ return computeRawVarint32Size(value);
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sfixed32} field.
+ */
+ public static int computeSFixed32SizeNoTag(final int value) {
+ return LITTLE_ENDIAN_32_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sfixed64} field.
+ */
+ public static int computeSFixed64SizeNoTag(final long value) {
+ return LITTLE_ENDIAN_64_SIZE;
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sint32} field.
+ */
+ public static int computeSInt32SizeNoTag(final int value) {
+ return computeRawVarint32Size(encodeZigZag32(value));
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode an
+ * {@code sint64} field.
+ */
+ public static int computeSInt64SizeNoTag(final long value) {
+ return computeRawVarint64Size(encodeZigZag64(value));
+ }
+
+ // =================================================================
+
+ /**
+ * Internal helper that writes the current buffer to the output. The
+ * buffer position is reset to its initial value when this returns.
+ */
+ private void refreshBuffer() throws IOException {
+ if (output == null) {
+ // We're writing to a single buffer.
+ throw new OutOfSpaceException();
+ }
+
+ // Since we have an output stream, this is our buffer
+ // and buffer offset == 0
+ output.write(buffer, 0, position);
+ position = 0;
+ }
+
+ /**
+ * Flushes the stream and forces any buffered bytes to be written. This
+ * does not flush the underlying OutputStream.
+ */
+ public void flush() throws IOException {
+ if (output != null) {
+ refreshBuffer();
+ }
+ }
+
+ /**
+ * If writing to a flat array, return the space left in the array.
+ * Otherwise, throws {@code UnsupportedOperationException}.
+ */
+ public int spaceLeft() {
+ if (output == null) {
+ return limit - position;
+ } else {
+ throw new UnsupportedOperationException(
+ "spaceLeft() can only be called on CodedOutputStreams that are " +
+ "writing to a flat array.");
+ }
+ }
+
+ /**
+ * Verifies that {@link #spaceLeft()} returns zero. It's common to create
+ * a byte array that is exactly big enough to hold a message, then write to
+ * it with a {@code CodedOutputStream}. Calling {@code checkNoSpaceLeft()}
+ * after writing verifies that the message was actually as big as expected,
+ * which can help catch bugs.
+ */
+ public void checkNoSpaceLeft() {
+ if (spaceLeft() != 0) {
+ throw new IllegalStateException(
+ "Did not write as much data as expected.");
+ }
+ }
+
+ /**
+ * If you create a CodedOutputStream around a simple flat array, you must
+ * not attempt to write more bytes than the array has space. Otherwise,
+ * this exception will be thrown.
+ */
+ public static class OutOfSpaceException extends IOException {
+ private static final long serialVersionUID = -6947486886997889499L;
+
+ OutOfSpaceException() {
+ super("CodedOutputStream was writing to a flat byte array and ran " +
+ "out of space.");
+ }
+ }
+
+ /** Write a single byte. */
+ public void writeRawByte(final byte value) throws IOException {
+ if (position == limit) {
+ refreshBuffer();
+ }
+
+ buffer[position++] = value;
+ }
+
+ /** Write a single byte, represented by an integer value. */
+ public void writeRawByte(final int value) throws IOException {
+ writeRawByte((byte) value);
+ }
+
+ /** Write an array of bytes. */
+ public void writeRawBytes(final byte[] value) throws IOException {
+ writeRawBytes(value, 0, value.length);
+ }
+
+ /** Write part of an array of bytes. */
+ public void writeRawBytes(final byte[] value, int offset, int length)
+ throws IOException {
+ if (limit - position >= length) {
+ // We have room in the current buffer.
+ System.arraycopy(value, offset, buffer, position, length);
+ position += length;
+ } else {
+ // Write extends past current buffer. Fill the rest of this buffer and
+ // flush.
+ final int bytesWritten = limit - position;
+ System.arraycopy(value, offset, buffer, position, bytesWritten);
+ offset += bytesWritten;
+ length -= bytesWritten;
+ position = limit;
+ refreshBuffer();
+
+ // Now deal with the rest.
+ // Since we have an output stream, this is our buffer
+ // and buffer offset == 0
+ if (length <= limit) {
+ // Fits in new buffer.
+ System.arraycopy(value, offset, buffer, 0, length);
+ position = length;
+ } else {
+ // Write is very big. Let's do it all at once.
+ output.write(value, offset, length);
+ }
+ }
+ }
+
+ /** Encode and write a tag. */
+ public void writeTag(final int fieldNumber, final int wireType)
+ throws IOException {
+ writeRawVarint32(WireFormatMicro.makeTag(fieldNumber, wireType));
+ }
+
+ /** Compute the number of bytes that would be needed to encode a tag. */
+ public static int computeTagSize(final int fieldNumber) {
+ return computeRawVarint32Size(WireFormatMicro.makeTag(fieldNumber, 0));
+ }
+
+ /**
+ * Encode and write a varint. {@code value} is treated as
+ * unsigned, so it won't be sign-extended if negative.
+ */
+ public void writeRawVarint32(int value) throws IOException {
+ while (true) {
+ if ((value & ~0x7F) == 0) {
+ writeRawByte(value);
+ return;
+ } else {
+ writeRawByte((value & 0x7F) | 0x80);
+ value >>>= 7;
+ }
+ }
+ }
+
+ /**
+ * Compute the number of bytes that would be needed to encode a varint.
+ * {@code value} is treated as unsigned, so it won't be sign-extended if
+ * negative.
+ */
+ public static int computeRawVarint32Size(final int value) {
+ if ((value & (0xffffffff << 7)) == 0) return 1;
+ if ((value & (0xffffffff << 14)) == 0) return 2;
+ if ((value & (0xffffffff << 21)) == 0) return 3;
+ if ((value & (0xffffffff << 28)) == 0) return 4;
+ return 5;
+ }
+
+ /** Encode and write a varint. */
+ public void writeRawVarint64(long value) throws IOException {
+ while (true) {
+ if ((value & ~0x7FL) == 0) {
+ writeRawByte((int)value);
+ return;
+ } else {
+ writeRawByte(((int)value & 0x7F) | 0x80);
+ value >>>= 7;
+ }
+ }
+ }
+
+ /** Compute the number of bytes that would be needed to encode a varint. */
+ public static int computeRawVarint64Size(final long value) {
+ if ((value & (0xffffffffffffffffL << 7)) == 0) return 1;
+ if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
+ if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
+ if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
+ if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
+ if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
+ if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
+ if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
+ if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
+ return 10;
+ }
+
+ /** Write a little-endian 32-bit integer. */
+ public void writeRawLittleEndian32(final int value) throws IOException {
+ writeRawByte((value ) & 0xFF);
+ writeRawByte((value >> 8) & 0xFF);
+ writeRawByte((value >> 16) & 0xFF);
+ writeRawByte((value >> 24) & 0xFF);
+ }
+
+ public static final int LITTLE_ENDIAN_32_SIZE = 4;
+
+ /** Write a little-endian 64-bit integer. */
+ public void writeRawLittleEndian64(final long value) throws IOException {
+ writeRawByte((int)(value ) & 0xFF);
+ writeRawByte((int)(value >> 8) & 0xFF);
+ writeRawByte((int)(value >> 16) & 0xFF);
+ writeRawByte((int)(value >> 24) & 0xFF);
+ writeRawByte((int)(value >> 32) & 0xFF);
+ writeRawByte((int)(value >> 40) & 0xFF);
+ writeRawByte((int)(value >> 48) & 0xFF);
+ writeRawByte((int)(value >> 56) & 0xFF);
+ }
+
+ public static final int LITTLE_ENDIAN_64_SIZE = 8;
+
+ /**
+ * Encode a ZigZag-encoded 32-bit value. ZigZag encodes signed integers
+ * into values that can be efficiently encoded with varint. (Otherwise,
+ * negative values must be sign-extended to 64 bits to be varint encoded,
+ * thus always taking 10 bytes on the wire.)
+ *
+ * @param n A signed 32-bit integer.
+ * @return An unsigned 32-bit integer, stored in a signed int because
+ * Java has no explicit unsigned support.
+ */
+ public static int encodeZigZag32(final int n) {
+ // Note: the right-shift must be arithmetic
+ return (n << 1) ^ (n >> 31);
+ }
+
+ /**
+ * Encode a ZigZag-encoded 64-bit value. ZigZag encodes signed integers
+ * into values that can be efficiently encoded with varint. (Otherwise,
+ * negative values must be sign-extended to 64 bits to be varint encoded,
+ * thus always taking 10 bytes on the wire.)
+ *
+ * @param n A signed 64-bit integer.
+ * @return An unsigned 64-bit integer, stored in a signed int because
+ * Java has no explicit unsigned support.
+ */
+ public static long encodeZigZag64(final long n) {
+ // Note: the right-shift must be arithmetic
+ return (n << 1) ^ (n >> 63);
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/InvalidProtocolBufferMicroException.java b/java/src/main/java/com/google/protobuf/micro/InvalidProtocolBufferMicroException.java
new file mode 100644
index 0000000..050f99b
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/InvalidProtocolBufferMicroException.java
@@ -0,0 +1,93 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+import java.io.IOException;
+
+/**
+ * Thrown when a protocol message being parsed is invalid in some way,
+ * e.g. it contains a malformed varint or a negative byte length.
+ *
+ * @author kenton@google.com Kenton Varda
+ */
+public class InvalidProtocolBufferMicroException extends IOException {
+ private static final long serialVersionUID = -1616151763072450476L;
+
+ public InvalidProtocolBufferMicroException(final String description) {
+ super(description);
+ }
+
+ static InvalidProtocolBufferMicroException truncatedMessage() {
+ return new InvalidProtocolBufferMicroException(
+ "While parsing a protocol message, the input ended unexpectedly " +
+ "in the middle of a field. This could mean either than the " +
+ "input has been truncated or that an embedded message " +
+ "misreported its own length.");
+ }
+
+ static InvalidProtocolBufferMicroException negativeSize() {
+ return new InvalidProtocolBufferMicroException(
+ "CodedInputStream encountered an embedded string or message " +
+ "which claimed to have negative size.");
+ }
+
+ static InvalidProtocolBufferMicroException malformedVarint() {
+ return new InvalidProtocolBufferMicroException(
+ "CodedInputStream encountered a malformed varint.");
+ }
+
+ static InvalidProtocolBufferMicroException invalidTag() {
+ return new InvalidProtocolBufferMicroException(
+ "Protocol message contained an invalid tag (zero).");
+ }
+
+ static InvalidProtocolBufferMicroException invalidEndTag() {
+ return new InvalidProtocolBufferMicroException(
+ "Protocol message end-group tag did not match expected tag.");
+ }
+
+ static InvalidProtocolBufferMicroException invalidWireType() {
+ return new InvalidProtocolBufferMicroException(
+ "Protocol message tag had invalid wire type.");
+ }
+
+ static InvalidProtocolBufferMicroException recursionLimitExceeded() {
+ return new InvalidProtocolBufferMicroException(
+ "Protocol message had too many levels of nesting. May be malicious. " +
+ "Use CodedInputStream.setRecursionLimit() to increase the depth limit.");
+ }
+
+ static InvalidProtocolBufferMicroException sizeLimitExceeded() {
+ return new InvalidProtocolBufferMicroException(
+ "Protocol message was too large. May be malicious. " +
+ "Use CodedInputStream.setSizeLimit() to increase the size limit.");
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/MessageMicro.java b/java/src/main/java/com/google/protobuf/micro/MessageMicro.java
new file mode 100644
index 0000000..0c02793
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/MessageMicro.java
@@ -0,0 +1,136 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+import com.google.protobuf.micro.CodedOutputStreamMicro;
+import java.io.IOException;
+
+/**
+ * Abstract interface implemented by Protocol Message objects.
+ *
+ * @author wink@google.com Wink Saville
+ */
+public abstract class MessageMicro {
+ /**
+ * Get the number of bytes required to encode this message.
+ * Returns the cached size or calls getSerializedSize which
+ * sets the cached size. This is used internally when serializing
+ * so the size is only computed once. If a member is modified
+ * then this could be stale call getSerializedSize if in doubt.
+ */
+ abstract public int getCachedSize();
+
+ /**
+ * Computes the number of bytes required to encode this message.
+ * The size is cached and the cached result can be retrieved
+ * using getCachedSize().
+ */
+ abstract public int getSerializedSize();
+
+ /**
+ * Serializes the message and writes it to {@code output}. This does not
+ * flush or close the stream.
+ */
+ abstract public void writeTo(CodedOutputStreamMicro output) throws java.io.IOException;
+
+ /**
+ * Parse {@code input} as a message of this type and merge it with the
+ * message being built.
+ */
+ abstract public MessageMicro mergeFrom(final CodedInputStreamMicro input) throws IOException;
+
+ /**
+ * Serialize to a byte array.
+ * @return byte array with the serialized data.
+ */
+ public byte[] toByteArray() {
+ final byte[] result = new byte[getSerializedSize()];
+ toByteArray(result, 0, result.length);
+ return result;
+ }
+
+ /**
+ * Serialize to a byte array starting at offset through length. The
+ * method getSerializedSize must have been called prior to calling
+ * this method so the proper length is know. If an attempt to
+ * write more than length bytes OutOfSpaceException will be thrown
+ * and if length bytes are not written then IllegalStateException
+ * is thrown.
+ * @return byte array with the serialized data.
+ */
+ public void toByteArray(byte [] data, int offset, int length) {
+ try {
+ final CodedOutputStreamMicro output = CodedOutputStreamMicro.newInstance(data, offset, length);
+ writeTo(output);
+ output.checkNoSpaceLeft();
+ } catch (IOException e) {
+ throw new RuntimeException("Serializing to a byte array threw an IOException "
+ + "(should never happen).");
+ }
+ }
+
+ /**
+ * Parse {@code data} as a message of this type and merge it with the
+ * message being built.
+ */
+ public MessageMicro mergeFrom(final byte[] data) throws InvalidProtocolBufferMicroException {
+ return mergeFrom(data, 0, data.length);
+ }
+
+ /**
+ * Parse {@code data} as a message of this type and merge it with the
+ * message being built.
+ */
+ public MessageMicro mergeFrom(final byte[] data, final int off, final int len)
+ throws InvalidProtocolBufferMicroException {
+ try {
+ final CodedInputStreamMicro input = CodedInputStreamMicro.newInstance(data, off, len);
+ mergeFrom(input);
+ input.checkLastTagWas(0);
+ return this;
+ } catch (InvalidProtocolBufferMicroException e) {
+ throw e;
+ } catch (IOException e) {
+ throw new RuntimeException("Reading from a byte array threw an IOException (should "
+ + "never happen).");
+ }
+ }
+
+ /**
+ * Called by subclasses to parse an unknown field.
+ * @return {@code true} unless the tag is an end-group tag.
+ */
+ protected boolean parseUnknownField(
+ final CodedInputStreamMicro input,
+ final int tag) throws IOException {
+ return input.skipField(tag);
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/StringUtf8Micro.java b/java/src/main/java/com/google/protobuf/micro/StringUtf8Micro.java
new file mode 100644
index 0000000..0c43e54
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/StringUtf8Micro.java
@@ -0,0 +1,67 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+/**
+ * A surogate for a String with a UTF8 representation.
+ *
+ * @author wink@google.com Wink Saville
+ */
+public final class StringUtf8Micro {
+ private String string;
+ private byte[] bytes;
+
+ public StringUtf8Micro(String string) {
+ setString(string);
+ }
+
+ public static final StringUtf8Micro EMPTY = new StringUtf8Micro("");
+
+ public String getString() {
+ return string;
+ }
+
+ public void setString(String string) {
+ this.string = string;
+ bytes = null;
+ }
+
+ public byte [] getBytes() {
+ if (bytes == null) {
+ try {
+ bytes = string.getBytes("UTF-8");
+ } catch (java.io.UnsupportedEncodingException e) {
+ throw new RuntimeException("UTF-8 not supported.");
+ }
+ }
+ return bytes;
+ }
+}
diff --git a/java/src/main/java/com/google/protobuf/micro/WireFormatMicro.java b/java/src/main/java/com/google/protobuf/micro/WireFormatMicro.java
new file mode 100644
index 0000000..d8a88bd
--- /dev/null
+++ b/java/src/main/java/com/google/protobuf/micro/WireFormatMicro.java
@@ -0,0 +1,87 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.micro;
+
+/**
+ * This class is used internally by the Protocol Buffer library and generated
+ * message implementations. It is public only because those generated messages
+ * do not reside in the {@code protobuf} package. Others should not use this
+ * class directly.
+ *
+ * This class contains constants and helper functions useful for dealing with
+ * the Protocol Buffer wire format.
+ *
+ * @author kenton@google.com Kenton Varda
+ */
+public final class WireFormatMicro {
+ // Do not allow instantiation.
+ private WireFormatMicro() {}
+
+ static final int WIRETYPE_VARINT = 0;
+ static final int WIRETYPE_FIXED64 = 1;
+ static final int WIRETYPE_LENGTH_DELIMITED = 2;
+ static final int WIRETYPE_START_GROUP = 3;
+ static final int WIRETYPE_END_GROUP = 4;
+ static final int WIRETYPE_FIXED32 = 5;
+
+ static final int TAG_TYPE_BITS = 3;
+ static final int TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1;
+
+ /** Given a tag value, determines the wire type (the lower 3 bits). */
+ static int getTagWireType(final int tag) {
+ return tag & TAG_TYPE_MASK;
+ }
+
+ /** Given a tag value, determines the field number (the upper 29 bits). */
+ public static int getTagFieldNumber(final int tag) {
+ return tag >>> TAG_TYPE_BITS;
+ }
+
+ /** Makes a tag value given a field number and wire type. */
+ static int makeTag(final int fieldNumber, final int wireType) {
+ return (fieldNumber << TAG_TYPE_BITS) | wireType;
+ }
+
+ // Field numbers for feilds in MessageSet wire format.
+ static final int MESSAGE_SET_ITEM = 1;
+ static final int MESSAGE_SET_TYPE_ID = 2;
+ static final int MESSAGE_SET_MESSAGE = 3;
+
+ // Tag numbers.
+ static final int MESSAGE_SET_ITEM_TAG =
+ makeTag(MESSAGE_SET_ITEM, WIRETYPE_START_GROUP);
+ static final int MESSAGE_SET_ITEM_END_TAG =
+ makeTag(MESSAGE_SET_ITEM, WIRETYPE_END_GROUP);
+ static final int MESSAGE_SET_TYPE_ID_TAG =
+ makeTag(MESSAGE_SET_TYPE_ID, WIRETYPE_VARINT);
+ static final int MESSAGE_SET_MESSAGE_TAG =
+ makeTag(MESSAGE_SET_MESSAGE, WIRETYPE_LENGTH_DELIMITED);
+}
diff --git a/java/src/test/java/com/google/protobuf/MicroTest.java b/java/src/test/java/com/google/protobuf/MicroTest.java
new file mode 100644
index 0000000..ebfccc2
--- /dev/null
+++ b/java/src/test/java/com/google/protobuf/MicroTest.java
@@ -0,0 +1,2138 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf;
+
+import com.google.protobuf.micro.MicroOuterClass;
+import com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro;
+import com.google.protobuf.micro.RecursiveMessageMicro;
+import com.google.protobuf.micro.SimpleMessageMicro;
+import com.google.protobuf.micro.StringUtf8;
+import com.google.protobuf.micro.StringUtf8Micro;
+import com.google.protobuf.micro.UnittestImportMicro;
+import com.google.protobuf.micro.ByteStringMicro;
+
+import junit.framework.TestCase;
+
+/**
+ * Test micro runtime.
+ *
+ * @author wink@google.com Wink Saville
+ */
+public class MicroTest extends TestCase {
+ public void setUp() throws Exception {
+ }
+
+ public void testSimpleMessageMicro() throws Exception {
+ SimpleMessageMicro msg = new SimpleMessageMicro();
+ assertFalse(msg.hasD());
+ assertEquals(123, msg.getD());
+ assertFalse(msg.hasNestedMsg());
+ assertEquals(null, msg.getNestedMsg());
+ assertFalse(msg.hasDefaultNestedEnum());
+ assertEquals(SimpleMessageMicro.BAZ, msg.getDefaultNestedEnum());
+
+ msg.setD(456);
+ assertTrue(msg.hasD());
+ assertEquals(456, msg.getD());
+ msg.clearD()
+ .setD(456);
+ assertTrue(msg.hasD());
+
+ SimpleMessageMicro.NestedMessage nestedMsg = new SimpleMessageMicro.NestedMessage()
+ .setBb(2);
+ assertTrue(nestedMsg.hasBb());
+ assertEquals(2, nestedMsg.getBb());
+ msg.setNestedMsg(nestedMsg);
+ assertTrue(msg.hasNestedMsg());
+ assertEquals(2, msg.getNestedMsg().getBb());
+
+ msg.setDefaultNestedEnum(SimpleMessageMicro.BAR);
+ assertTrue(msg.hasDefaultNestedEnum());
+ assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
+
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 9);
+ assertEquals(result.length, msgSerializedSize);
+
+ SimpleMessageMicro newMsg = SimpleMessageMicro.parseFrom(result);
+ assertTrue(newMsg.hasD());
+ assertTrue(newMsg.hasNestedMsg());
+ assertTrue(newMsg.hasDefaultNestedEnum());
+ assertEquals(456, newMsg.getD());
+ assertEquals(2, msg.getNestedMsg().getBb());
+ assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
+ }
+
+ public void testRecursiveMessageMicro() throws Exception {
+ RecursiveMessageMicro msg = new RecursiveMessageMicro();
+ assertFalse(msg.hasId());
+ assertFalse(msg.hasNestedMessage());
+ assertFalse(msg.hasOptionalRecursiveMessageMicro());
+ assertEquals(0, msg.getRepeatedRecursiveMessageMicroCount());
+
+ RecursiveMessageMicro msg1 = new RecursiveMessageMicro();
+ msg1.setId(1);
+ assertEquals(1, msg1.getId());
+ RecursiveMessageMicro msg2 = new RecursiveMessageMicro();
+ msg2.setId(2);
+ RecursiveMessageMicro msg3 = new RecursiveMessageMicro();
+ msg3.setId(3);
+
+ RecursiveMessageMicro.NestedMessage nestedMsg = new RecursiveMessageMicro.NestedMessage();
+ nestedMsg.setA(msg1);
+ assertEquals(1, nestedMsg.getA().getId());
+
+ msg.setId(0);
+ msg.setNestedMessage(nestedMsg);
+ msg.setOptionalRecursiveMessageMicro(msg2);
+ msg.addRepeatedRecursiveMessageMicro(msg3);
+
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 16);
+ assertEquals(result.length, msgSerializedSize);
+
+ RecursiveMessageMicro newMsg = RecursiveMessageMicro.parseFrom(result);
+ assertTrue(newMsg.hasId());
+ assertTrue(newMsg.hasNestedMessage());
+ assertTrue(newMsg.hasOptionalRecursiveMessageMicro());
+ assertEquals(1, newMsg.getRepeatedRecursiveMessageMicroCount());
+
+ assertEquals(0, newMsg.getId());
+ assertEquals(1, newMsg.getNestedMessage().getA().getId());
+ assertEquals(2, newMsg.getOptionalRecursiveMessageMicro().getId());
+ assertEquals(3, newMsg.getRepeatedRecursiveMessageMicro(0).getId());
+ }
+
+ public void testMicroRequiredInt32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasId());
+ assertFalse(msg.isInitialized());
+ msg.setId(123);
+ assertTrue(msg.hasId());
+ assertTrue(msg.isInitialized());
+ assertEquals(123, msg.getId());
+ msg.clearId();
+ assertFalse(msg.hasId());
+ assertFalse(msg.isInitialized());
+ msg.clearId()
+ .setId(456);
+ assertTrue(msg.hasId());
+ msg.clear();
+ assertFalse(msg.hasId());
+ assertFalse(msg.isInitialized());
+
+ msg.setId(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasId());
+ assertTrue(newMsg.isInitialized());
+ assertEquals(123, newMsg.getId());
+ }
+
+ public void testMicroOptionalInt32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalInt32());
+ msg.setOptionalInt32(123);
+ assertTrue(msg.hasOptionalInt32());
+ assertEquals(123, msg.getOptionalInt32());
+ msg.clearOptionalInt32();
+ assertFalse(msg.hasOptionalInt32());
+ msg.clearOptionalInt32()
+ .setOptionalInt32(456);
+ assertTrue(msg.hasOptionalInt32());
+ msg.clear();
+ assertFalse(msg.hasOptionalInt32());
+
+ msg.setOptionalInt32(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 2);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalInt32());
+ assertEquals(123, newMsg.getOptionalInt32());
+ }
+
+ public void testMicroOptionalInt64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalInt64());
+ msg.setOptionalInt64(123);
+ assertTrue(msg.hasOptionalInt64());
+ assertEquals(123, msg.getOptionalInt64());
+ msg.clearOptionalInt64();
+ assertFalse(msg.hasOptionalInt64());
+ msg.clearOptionalInt64()
+ .setOptionalInt64(456);
+ assertTrue(msg.hasOptionalInt64());
+ msg.clear();
+ assertFalse(msg.hasOptionalInt64());
+
+ msg.setOptionalInt64(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 2);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalInt64());
+ assertEquals(123, newMsg.getOptionalInt64());
+ }
+
+ public void testMicroOptionalUint32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalUint32());
+ msg.setOptionalUint32(123);
+ assertTrue(msg.hasOptionalUint32());
+ assertEquals(123, msg.getOptionalUint32());
+ msg.clearOptionalUint32();
+ assertFalse(msg.hasOptionalUint32());
+ msg.clearOptionalUint32()
+ .setOptionalUint32(456);
+ assertTrue(msg.hasOptionalUint32());
+ msg.clear();
+ assertFalse(msg.hasOptionalUint32());
+
+ msg.setOptionalUint32(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 2);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalUint32());
+ assertEquals(123, newMsg.getOptionalUint32());
+ }
+
+ public void testMicroOptionalUint64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalUint64());
+ msg.setOptionalUint64(123);
+ assertTrue(msg.hasOptionalUint64());
+ assertEquals(123, msg.getOptionalUint64());
+ msg.clearOptionalUint64();
+ assertFalse(msg.hasOptionalUint64());
+ msg.clearOptionalUint64()
+ .setOptionalUint64(456);
+ assertTrue(msg.hasOptionalUint64());
+ msg.clear();
+ assertFalse(msg.hasOptionalUint64());
+
+ msg.setOptionalUint64(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 2);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalUint64());
+ assertEquals(123, newMsg.getOptionalUint64());
+ }
+
+ public void testMicroOptionalSint32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalSint32());
+ msg.setOptionalSint32(123);
+ assertTrue(msg.hasOptionalSint32());
+ assertEquals(123, msg.getOptionalSint32());
+ msg.clearOptionalSint32();
+ assertFalse(msg.hasOptionalSint32());
+ msg.clearOptionalSint32()
+ .setOptionalSint32(456);
+ assertTrue(msg.hasOptionalSint32());
+ msg.clear();
+ assertFalse(msg.hasOptionalSint32());
+
+ msg.setOptionalSint32(-123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalSint32());
+ assertEquals(-123, newMsg.getOptionalSint32());
+ }
+
+ public void testMicroOptionalSint64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalSint64());
+ msg.setOptionalSint64(123);
+ assertTrue(msg.hasOptionalSint64());
+ assertEquals(123, msg.getOptionalSint64());
+ msg.clearOptionalSint64();
+ assertFalse(msg.hasOptionalSint64());
+ msg.clearOptionalSint64()
+ .setOptionalSint64(456);
+ assertTrue(msg.hasOptionalSint64());
+ msg.clear();
+ assertFalse(msg.hasOptionalSint64());
+
+ msg.setOptionalSint64(-123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalSint64());
+ assertEquals(-123, newMsg.getOptionalSint64());
+ }
+
+ public void testMicroOptionalFixed32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalFixed32());
+ msg.setOptionalFixed32(123);
+ assertTrue(msg.hasOptionalFixed32());
+ assertEquals(123, msg.getOptionalFixed32());
+ msg.clearOptionalFixed32();
+ assertFalse(msg.hasOptionalFixed32());
+ msg.clearOptionalFixed32()
+ .setOptionalFixed32(456);
+ assertTrue(msg.hasOptionalFixed32());
+ msg.clear();
+ assertFalse(msg.hasOptionalFixed32());
+
+ msg.setOptionalFixed32(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalFixed32());
+ assertEquals(123, newMsg.getOptionalFixed32());
+ }
+
+ public void testMicroOptionalFixed64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalFixed64());
+ msg.setOptionalFixed64(123);
+ assertTrue(msg.hasOptionalFixed64());
+ assertEquals(123, msg.getOptionalFixed64());
+ msg.clearOptionalFixed64();
+ assertFalse(msg.hasOptionalFixed64());
+ msg.clearOptionalFixed64()
+ .setOptionalFixed64(456);
+ assertTrue(msg.hasOptionalFixed64());
+ msg.clear();
+ assertFalse(msg.hasOptionalFixed64());
+
+ msg.setOptionalFixed64(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 9);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalFixed64());
+ assertEquals(123, newMsg.getOptionalFixed64());
+ }
+ public void testMicroOptionalSfixed32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalSfixed32());
+ msg.setOptionalSfixed32(123);
+ assertTrue(msg.hasOptionalSfixed32());
+ assertEquals(123, msg.getOptionalSfixed32());
+ msg.clearOptionalSfixed32();
+ assertFalse(msg.hasOptionalSfixed32());
+ msg.clearOptionalSfixed32()
+ .setOptionalSfixed32(456);
+ assertTrue(msg.hasOptionalSfixed32());
+ msg.clear();
+ assertFalse(msg.hasOptionalSfixed32());
+
+ msg.setOptionalSfixed32(123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalSfixed32());
+ assertEquals(123, newMsg.getOptionalSfixed32());
+ }
+
+ public void testMicroOptionalSfixed64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalSfixed64());
+ msg.setOptionalSfixed64(123);
+ assertTrue(msg.hasOptionalSfixed64());
+ assertEquals(123, msg.getOptionalSfixed64());
+ msg.clearOptionalSfixed64();
+ assertFalse(msg.hasOptionalSfixed64());
+ msg.clearOptionalSfixed64()
+ .setOptionalSfixed64(456);
+ assertTrue(msg.hasOptionalSfixed64());
+ msg.clear();
+ assertFalse(msg.hasOptionalSfixed64());
+
+ msg.setOptionalSfixed64(-123);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 9);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalSfixed64());
+ assertEquals(-123, newMsg.getOptionalSfixed64());
+ }
+
+ public void testMicroOptionalFloat() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalFloat());
+ msg.setOptionalFloat(123f);
+ assertTrue(msg.hasOptionalFloat());
+ assertTrue(123.0f == msg.getOptionalFloat());
+ msg.clearOptionalFloat();
+ assertFalse(msg.hasOptionalFloat());
+ msg.clearOptionalFloat()
+ .setOptionalFloat(456.0f);
+ assertTrue(msg.hasOptionalFloat());
+ msg.clear();
+ assertFalse(msg.hasOptionalFloat());
+
+ msg.setOptionalFloat(-123.456f);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalFloat());
+ assertTrue(-123.456f == newMsg.getOptionalFloat());
+ }
+
+ public void testMicroOptionalDouble() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalDouble());
+ msg.setOptionalDouble(123);
+ assertTrue(msg.hasOptionalDouble());
+ assertTrue(123.0 == msg.getOptionalDouble());
+ msg.clearOptionalDouble();
+ assertFalse(msg.hasOptionalDouble());
+ msg.clearOptionalDouble()
+ .setOptionalDouble(456.0);
+ assertTrue(msg.hasOptionalDouble());
+ msg.clear();
+ assertFalse(msg.hasOptionalDouble());
+
+ msg.setOptionalDouble(-123.456);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 9);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalDouble());
+ assertTrue(-123.456 == newMsg.getOptionalDouble());
+ }
+
+ public void testMicroOptionalBool() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalBool());
+ msg.setOptionalBool(true);
+ assertTrue(msg.hasOptionalBool());
+ assertEquals(true, msg.getOptionalBool());
+ msg.clearOptionalBool();
+ assertFalse(msg.hasOptionalBool());
+ msg.clearOptionalBool()
+ .setOptionalBool(true);
+ assertTrue(msg.hasOptionalBool());
+ msg.clear();
+ assertFalse(msg.hasOptionalBool());
+
+ msg.setOptionalBool(false);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 2);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalBool());
+ assertEquals(false, newMsg.getOptionalBool());
+ }
+
+ public void testMicroOptionalString() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalString());
+ msg.setOptionalString("hello");
+ assertTrue(msg.hasOptionalString());
+ assertEquals("hello", msg.getOptionalString());
+ msg.clearOptionalString();
+ assertFalse(msg.hasOptionalString());
+ msg.clearOptionalString()
+ .setOptionalString("hello");
+ assertTrue(msg.hasOptionalString());
+ msg.clear();
+ assertFalse(msg.hasOptionalString());
+
+ msg.setOptionalString("bye");
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalString());
+ assertEquals("bye", newMsg.getOptionalString());
+ }
+
+ public void testMicroOptionalBytes() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalBytes());
+ msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
+ assertTrue(msg.hasOptionalBytes());
+ assertEquals("hello", msg.getOptionalBytes().toStringUtf8());
+ msg.clearOptionalBytes();
+ assertFalse(msg.hasOptionalBytes());
+ msg.clearOptionalBytes()
+ .setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
+ assertTrue(msg.hasOptionalBytes());
+ msg.clear();
+ assertFalse(msg.hasOptionalBytes());
+
+ msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("bye"));
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalBytes());
+ assertEquals("bye", newMsg.getOptionalBytes().toStringUtf8());
+ }
+
+ public void testMicroOptionalGroup() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ TestAllTypesMicro.OptionalGroup grp = new TestAllTypesMicro.OptionalGroup();
+ grp.setA(1);
+ assertFalse(msg.hasOptionalGroup());
+ msg.setOptionalGroup(grp);
+ assertTrue(msg.hasOptionalGroup());
+ assertEquals(1, msg.getOptionalGroup().getA());
+ msg.clearOptionalGroup();
+ assertFalse(msg.hasOptionalGroup());
+ msg.clearOptionalGroup()
+ .setOptionalGroup(new TestAllTypesMicro.OptionalGroup().setA(2));
+ assertTrue(msg.hasOptionalGroup());
+ msg.clear();
+ assertFalse(msg.hasOptionalGroup());
+
+ msg.setOptionalGroup(grp);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalGroup());
+ assertEquals(1, newMsg.getOptionalGroup().getA());
+ }
+
+ public void testMicroOptionalNestedMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ TestAllTypesMicro.NestedMessage nestedMsg = new TestAllTypesMicro.NestedMessage();
+ nestedMsg.setBb(1);
+ assertFalse(msg.hasOptionalNestedMessage());
+ msg.setOptionalNestedMessage(nestedMsg);
+ assertTrue(msg.hasOptionalNestedMessage());
+ assertEquals(1, msg.getOptionalNestedMessage().getBb());
+ msg.clearOptionalNestedMessage();
+ assertFalse(msg.hasOptionalNestedMessage());
+ msg.clearOptionalNestedMessage()
+ .setOptionalNestedMessage(new TestAllTypesMicro.NestedMessage().setBb(2));
+ assertTrue(msg.hasOptionalNestedMessage());
+ msg.clear();
+ assertFalse(msg.hasOptionalNestedMessage());
+
+ msg.setOptionalNestedMessage(nestedMsg);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalNestedMessage());
+ assertEquals(1, newMsg.getOptionalNestedMessage().getBb());
+ }
+
+ public void testMicroOptionalForeignMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ MicroOuterClass.ForeignMessageMicro foreignMsg =
+ new MicroOuterClass.ForeignMessageMicro();
+ assertFalse(foreignMsg.hasC());
+ foreignMsg.setC(1);
+ assertTrue(foreignMsg.hasC());
+ assertFalse(msg.hasOptionalForeignMessage());
+ msg.setOptionalForeignMessage(foreignMsg);
+ assertTrue(msg.hasOptionalForeignMessage());
+ assertEquals(1, msg.getOptionalForeignMessage().getC());
+ msg.clearOptionalForeignMessage();
+ assertFalse(msg.hasOptionalForeignMessage());
+ msg.clearOptionalForeignMessage()
+ .setOptionalForeignMessage(new MicroOuterClass.ForeignMessageMicro().setC(2));
+ assertTrue(msg.hasOptionalForeignMessage());
+ msg.clear();
+ assertFalse(msg.hasOptionalForeignMessage());
+
+ msg.setOptionalForeignMessage(foreignMsg);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalForeignMessage());
+ assertEquals(1, newMsg.getOptionalForeignMessage().getC());
+ }
+
+ public void testMicroOptionalImportMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ UnittestImportMicro.ImportMessageMicro importMsg =
+ new UnittestImportMicro.ImportMessageMicro();
+ assertFalse(importMsg.hasD());
+ importMsg.setD(1);
+ assertTrue(importMsg.hasD());
+ assertFalse(msg.hasOptionalImportMessage());
+ msg.setOptionalImportMessage(importMsg);
+ assertTrue(msg.hasOptionalImportMessage());
+ assertEquals(1, msg.getOptionalImportMessage().getD());
+ msg.clearOptionalImportMessage();
+ assertFalse(msg.hasOptionalImportMessage());
+ msg.clearOptionalImportMessage()
+ .setOptionalImportMessage(new UnittestImportMicro.ImportMessageMicro().setD(2));
+ assertTrue(msg.hasOptionalImportMessage());
+ msg.clear();
+ assertFalse(msg.hasOptionalImportMessage());
+
+ msg.setOptionalImportMessage(importMsg);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalImportMessage());
+ assertEquals(1, newMsg.getOptionalImportMessage().getD());
+ }
+
+ public void testMicroOptionalNestedEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
+ assertTrue(msg.hasOptionalNestedEnum());
+ assertEquals(TestAllTypesMicro.BAR, msg.getOptionalNestedEnum());
+ msg.clearOptionalNestedEnum();
+ assertFalse(msg.hasOptionalNestedEnum());
+ msg.clearOptionalNestedEnum()
+ .setOptionalNestedEnum(TestAllTypesMicro.BAZ);
+ assertTrue(msg.hasOptionalNestedEnum());
+ msg.clear();
+ assertFalse(msg.hasOptionalNestedEnum());
+
+ msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalNestedEnum());
+ assertEquals(TestAllTypesMicro.BAR, newMsg.getOptionalNestedEnum());
+ }
+
+ public void testMicroOptionalForeignEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
+ assertTrue(msg.hasOptionalForeignEnum());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
+ msg.getOptionalForeignEnum());
+ msg.clearOptionalForeignEnum();
+ assertFalse(msg.hasOptionalForeignEnum());
+ msg.clearOptionalForeignEnum()
+ .setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAZ);
+ assertTrue(msg.hasOptionalForeignEnum());
+ msg.clear();
+ assertFalse(msg.hasOptionalForeignEnum());
+
+ msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalForeignEnum());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
+ newMsg.getOptionalForeignEnum());
+ }
+
+ public void testMicroOptionalImportEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
+ assertTrue(msg.hasOptionalImportEnum());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
+ msg.getOptionalImportEnum());
+ msg.clearOptionalImportEnum();
+ assertFalse(msg.hasOptionalImportEnum());
+ msg.clearOptionalImportEnum()
+ .setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAZ);
+ assertTrue(msg.hasOptionalImportEnum());
+ msg.clear();
+ assertFalse(msg.hasOptionalImportEnum());
+
+ msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalImportEnum());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
+ newMsg.getOptionalImportEnum());
+ }
+
+ public void testMicroOptionalStringPiece() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalStringPiece());
+ msg.setOptionalStringPiece("hello");
+ assertTrue(msg.hasOptionalStringPiece());
+ assertEquals("hello", msg.getOptionalStringPiece());
+ msg.clearOptionalStringPiece();
+ assertFalse(msg.hasOptionalStringPiece());
+ msg.clearOptionalStringPiece()
+ .setOptionalStringPiece("hello");
+ assertTrue(msg.hasOptionalStringPiece());
+ msg.clear();
+ assertFalse(msg.hasOptionalStringPiece());
+
+ msg.setOptionalStringPiece("bye");
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalStringPiece());
+ assertEquals("bye", newMsg.getOptionalStringPiece());
+ }
+
+ public void testMicroOptionalCord() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasOptionalCord());
+ msg.setOptionalCord("hello");
+ assertTrue(msg.hasOptionalCord());
+ assertEquals("hello", msg.getOptionalCord());
+ msg.clearOptionalCord();
+ assertFalse(msg.hasOptionalCord());
+ msg.clearOptionalCord()
+ .setOptionalCord("hello");
+ assertTrue(msg.hasOptionalCord());
+ msg.clear();
+ assertFalse(msg.hasOptionalCord());
+
+ msg.setOptionalCord("bye");
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertTrue(newMsg.hasOptionalCord());
+ assertEquals("bye", newMsg.getOptionalCord());
+ }
+
+ public void testMicroRepeatedInt32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedInt32Count());
+ msg.addRepeatedInt32(123);
+ assertEquals(1, msg.getRepeatedInt32Count());
+ assertEquals(123, msg.getRepeatedInt32(0));
+ msg.addRepeatedInt32(456);
+ assertEquals(2, msg.getRepeatedInt32Count());
+ assertEquals(123, msg.getRepeatedInt32(0));
+ assertEquals(456, msg.getRepeatedInt32(1));
+ msg.setRepeatedInt32(0, 789);
+ assertEquals(2, msg.getRepeatedInt32Count());
+ assertEquals(789, msg.getRepeatedInt32(0));
+ assertEquals(456, msg.getRepeatedInt32(1));
+ msg.clearRepeatedInt32();
+ assertEquals(0, msg.getRepeatedInt32Count());
+ msg.clearRepeatedInt32()
+ .addRepeatedInt32(456);
+ assertEquals(1, msg.getRepeatedInt32Count());
+ assertEquals(456, msg.getRepeatedInt32(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedInt32Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedInt32(123);
+ assertEquals(1, msg.getRepeatedInt32Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedInt32Count());
+ assertEquals(123, newMsg.getRepeatedInt32(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedInt32(123)
+ .addRepeatedInt32(456);
+ assertEquals(2, msg.getRepeatedInt32Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedInt32Count());
+ assertEquals(123, newMsg.getRepeatedInt32(0));
+ assertEquals(456, newMsg.getRepeatedInt32(1));
+ }
+
+ public void testMicroRepeatedInt64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedInt64Count());
+ msg.addRepeatedInt64(123);
+ assertEquals(1, msg.getRepeatedInt64Count());
+ assertEquals(123, msg.getRepeatedInt64(0));
+ msg.addRepeatedInt64(456);
+ assertEquals(2, msg.getRepeatedInt64Count());
+ assertEquals(123, msg.getRepeatedInt64(0));
+ assertEquals(456, msg.getRepeatedInt64(1));
+ msg.setRepeatedInt64(0, 789);
+ assertEquals(2, msg.getRepeatedInt64Count());
+ assertEquals(789, msg.getRepeatedInt64(0));
+ assertEquals(456, msg.getRepeatedInt64(1));
+ msg.clearRepeatedInt64();
+ assertEquals(0, msg.getRepeatedInt64Count());
+ msg.clearRepeatedInt64()
+ .addRepeatedInt64(456);
+ assertEquals(1, msg.getRepeatedInt64Count());
+ assertEquals(456, msg.getRepeatedInt64(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedInt64Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedInt64(123);
+ assertEquals(1, msg.getRepeatedInt64Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedInt64Count());
+ assertEquals(123, newMsg.getRepeatedInt64(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedInt64(123)
+ .addRepeatedInt64(456);
+ assertEquals(2, msg.getRepeatedInt64Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedInt64Count());
+ assertEquals(123, newMsg.getRepeatedInt64(0));
+ assertEquals(456, newMsg.getRepeatedInt64(1));
+ }
+
+ public void testMicroRepeatedUint32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedUint32Count());
+ msg.addRepeatedUint32(123);
+ assertEquals(1, msg.getRepeatedUint32Count());
+ assertEquals(123, msg.getRepeatedUint32(0));
+ msg.addRepeatedUint32(456);
+ assertEquals(2, msg.getRepeatedUint32Count());
+ assertEquals(123, msg.getRepeatedUint32(0));
+ assertEquals(456, msg.getRepeatedUint32(1));
+ msg.setRepeatedUint32(0, 789);
+ assertEquals(2, msg.getRepeatedUint32Count());
+ assertEquals(789, msg.getRepeatedUint32(0));
+ assertEquals(456, msg.getRepeatedUint32(1));
+ msg.clearRepeatedUint32();
+ assertEquals(0, msg.getRepeatedUint32Count());
+ msg.clearRepeatedUint32()
+ .addRepeatedUint32(456);
+ assertEquals(1, msg.getRepeatedUint32Count());
+ assertEquals(456, msg.getRepeatedUint32(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedUint32Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedUint32(123);
+ assertEquals(1, msg.getRepeatedUint32Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedUint32Count());
+ assertEquals(123, newMsg.getRepeatedUint32(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedUint32(123)
+ .addRepeatedUint32(456);
+ assertEquals(2, msg.getRepeatedUint32Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedUint32Count());
+ assertEquals(123, newMsg.getRepeatedUint32(0));
+ assertEquals(456, newMsg.getRepeatedUint32(1));
+ }
+
+ public void testMicroRepeatedUint64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedUint64Count());
+ msg.addRepeatedUint64(123);
+ assertEquals(1, msg.getRepeatedUint64Count());
+ assertEquals(123, msg.getRepeatedUint64(0));
+ msg.addRepeatedUint64(456);
+ assertEquals(2, msg.getRepeatedUint64Count());
+ assertEquals(123, msg.getRepeatedUint64(0));
+ assertEquals(456, msg.getRepeatedUint64(1));
+ msg.setRepeatedUint64(0, 789);
+ assertEquals(2, msg.getRepeatedUint64Count());
+ assertEquals(789, msg.getRepeatedUint64(0));
+ assertEquals(456, msg.getRepeatedUint64(1));
+ msg.clearRepeatedUint64();
+ assertEquals(0, msg.getRepeatedUint64Count());
+ msg.clearRepeatedUint64()
+ .addRepeatedUint64(456);
+ assertEquals(1, msg.getRepeatedUint64Count());
+ assertEquals(456, msg.getRepeatedUint64(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedUint64Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedUint64(123);
+ assertEquals(1, msg.getRepeatedUint64Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedUint64Count());
+ assertEquals(123, newMsg.getRepeatedUint64(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedUint64(123)
+ .addRepeatedUint64(456);
+ assertEquals(2, msg.getRepeatedUint64Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedUint64Count());
+ assertEquals(123, newMsg.getRepeatedUint64(0));
+ assertEquals(456, newMsg.getRepeatedUint64(1));
+ }
+
+ public void testMicroRepeatedSint32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedSint32Count());
+ msg.addRepeatedSint32(123);
+ assertEquals(1, msg.getRepeatedSint32Count());
+ assertEquals(123, msg.getRepeatedSint32(0));
+ msg.addRepeatedSint32(456);
+ assertEquals(2, msg.getRepeatedSint32Count());
+ assertEquals(123, msg.getRepeatedSint32(0));
+ assertEquals(456, msg.getRepeatedSint32(1));
+ msg.setRepeatedSint32(0, 789);
+ assertEquals(2, msg.getRepeatedSint32Count());
+ assertEquals(789, msg.getRepeatedSint32(0));
+ assertEquals(456, msg.getRepeatedSint32(1));
+ msg.clearRepeatedSint32();
+ assertEquals(0, msg.getRepeatedSint32Count());
+ msg.clearRepeatedSint32()
+ .addRepeatedSint32(456);
+ assertEquals(1, msg.getRepeatedSint32Count());
+ assertEquals(456, msg.getRepeatedSint32(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedSint32Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedSint32(123);
+ assertEquals(1, msg.getRepeatedSint32Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 4);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedSint32Count());
+ assertEquals(123, newMsg.getRepeatedSint32(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedSint32(123)
+ .addRepeatedSint32(456);
+ assertEquals(2, msg.getRepeatedSint32Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 8);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedSint32Count());
+ assertEquals(123, newMsg.getRepeatedSint32(0));
+ assertEquals(456, newMsg.getRepeatedSint32(1));
+ }
+
+ public void testMicroRepeatedSint64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedSint64Count());
+ msg.addRepeatedSint64(123);
+ assertEquals(1, msg.getRepeatedSint64Count());
+ assertEquals(123, msg.getRepeatedSint64(0));
+ msg.addRepeatedSint64(456);
+ assertEquals(2, msg.getRepeatedSint64Count());
+ assertEquals(123, msg.getRepeatedSint64(0));
+ assertEquals(456, msg.getRepeatedSint64(1));
+ msg.setRepeatedSint64(0, 789);
+ assertEquals(2, msg.getRepeatedSint64Count());
+ assertEquals(789, msg.getRepeatedSint64(0));
+ assertEquals(456, msg.getRepeatedSint64(1));
+ msg.clearRepeatedSint64();
+ assertEquals(0, msg.getRepeatedSint64Count());
+ msg.clearRepeatedSint64()
+ .addRepeatedSint64(456);
+ assertEquals(1, msg.getRepeatedSint64Count());
+ assertEquals(456, msg.getRepeatedSint64(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedSint64Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedSint64(123);
+ assertEquals(1, msg.getRepeatedSint64Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 4);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedSint64Count());
+ assertEquals(123, newMsg.getRepeatedSint64(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedSint64(123)
+ .addRepeatedSint64(456);
+ assertEquals(2, msg.getRepeatedSint64Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 8);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedSint64Count());
+ assertEquals(123, newMsg.getRepeatedSint64(0));
+ assertEquals(456, newMsg.getRepeatedSint64(1));
+ }
+
+ public void testMicroRepeatedFixed32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedFixed32Count());
+ msg.addRepeatedFixed32(123);
+ assertEquals(1, msg.getRepeatedFixed32Count());
+ assertEquals(123, msg.getRepeatedFixed32(0));
+ msg.addRepeatedFixed32(456);
+ assertEquals(2, msg.getRepeatedFixed32Count());
+ assertEquals(123, msg.getRepeatedFixed32(0));
+ assertEquals(456, msg.getRepeatedFixed32(1));
+ msg.setRepeatedFixed32(0, 789);
+ assertEquals(2, msg.getRepeatedFixed32Count());
+ assertEquals(789, msg.getRepeatedFixed32(0));
+ assertEquals(456, msg.getRepeatedFixed32(1));
+ msg.clearRepeatedFixed32();
+ assertEquals(0, msg.getRepeatedFixed32Count());
+ msg.clearRepeatedFixed32()
+ .addRepeatedFixed32(456);
+ assertEquals(1, msg.getRepeatedFixed32Count());
+ assertEquals(456, msg.getRepeatedFixed32(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedFixed32Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedFixed32(123);
+ assertEquals(1, msg.getRepeatedFixed32Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedFixed32Count());
+ assertEquals(123, newMsg.getRepeatedFixed32(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedFixed32(123)
+ .addRepeatedFixed32(456);
+ assertEquals(2, msg.getRepeatedFixed32Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 12);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedFixed32Count());
+ assertEquals(123, newMsg.getRepeatedFixed32(0));
+ assertEquals(456, newMsg.getRepeatedFixed32(1));
+ }
+
+ public void testMicroRepeatedFixed64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedFixed64Count());
+ msg.addRepeatedFixed64(123);
+ assertEquals(1, msg.getRepeatedFixed64Count());
+ assertEquals(123, msg.getRepeatedFixed64(0));
+ msg.addRepeatedFixed64(456);
+ assertEquals(2, msg.getRepeatedFixed64Count());
+ assertEquals(123, msg.getRepeatedFixed64(0));
+ assertEquals(456, msg.getRepeatedFixed64(1));
+ msg.setRepeatedFixed64(0, 789);
+ assertEquals(2, msg.getRepeatedFixed64Count());
+ assertEquals(789, msg.getRepeatedFixed64(0));
+ assertEquals(456, msg.getRepeatedFixed64(1));
+ msg.clearRepeatedFixed64();
+ assertEquals(0, msg.getRepeatedFixed64Count());
+ msg.clearRepeatedFixed64()
+ .addRepeatedFixed64(456);
+ assertEquals(1, msg.getRepeatedFixed64Count());
+ assertEquals(456, msg.getRepeatedFixed64(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedFixed64Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedFixed64(123);
+ assertEquals(1, msg.getRepeatedFixed64Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedFixed64Count());
+ assertEquals(123, newMsg.getRepeatedFixed64(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedFixed64(123)
+ .addRepeatedFixed64(456);
+ assertEquals(2, msg.getRepeatedFixed64Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 20);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedFixed64Count());
+ assertEquals(123, newMsg.getRepeatedFixed64(0));
+ assertEquals(456, newMsg.getRepeatedFixed64(1));
+ }
+
+ public void testMicroRepeatedSfixed32() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedSfixed32Count());
+ msg.addRepeatedSfixed32(123);
+ assertEquals(1, msg.getRepeatedSfixed32Count());
+ assertEquals(123, msg.getRepeatedSfixed32(0));
+ msg.addRepeatedSfixed32(456);
+ assertEquals(2, msg.getRepeatedSfixed32Count());
+ assertEquals(123, msg.getRepeatedSfixed32(0));
+ assertEquals(456, msg.getRepeatedSfixed32(1));
+ msg.setRepeatedSfixed32(0, 789);
+ assertEquals(2, msg.getRepeatedSfixed32Count());
+ assertEquals(789, msg.getRepeatedSfixed32(0));
+ assertEquals(456, msg.getRepeatedSfixed32(1));
+ msg.clearRepeatedSfixed32();
+ assertEquals(0, msg.getRepeatedSfixed32Count());
+ msg.clearRepeatedSfixed32()
+ .addRepeatedSfixed32(456);
+ assertEquals(1, msg.getRepeatedSfixed32Count());
+ assertEquals(456, msg.getRepeatedSfixed32(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedSfixed32Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedSfixed32(123);
+ assertEquals(1, msg.getRepeatedSfixed32Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedSfixed32Count());
+ assertEquals(123, newMsg.getRepeatedSfixed32(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedSfixed32(123)
+ .addRepeatedSfixed32(456);
+ assertEquals(2, msg.getRepeatedSfixed32Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 12);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedSfixed32Count());
+ assertEquals(123, newMsg.getRepeatedSfixed32(0));
+ assertEquals(456, newMsg.getRepeatedSfixed32(1));
+ }
+
+ public void testMicroRepeatedSfixed64() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedSfixed64Count());
+ msg.addRepeatedSfixed64(123);
+ assertEquals(1, msg.getRepeatedSfixed64Count());
+ assertEquals(123, msg.getRepeatedSfixed64(0));
+ msg.addRepeatedSfixed64(456);
+ assertEquals(2, msg.getRepeatedSfixed64Count());
+ assertEquals(123, msg.getRepeatedSfixed64(0));
+ assertEquals(456, msg.getRepeatedSfixed64(1));
+ msg.setRepeatedSfixed64(0, 789);
+ assertEquals(2, msg.getRepeatedSfixed64Count());
+ assertEquals(789, msg.getRepeatedSfixed64(0));
+ assertEquals(456, msg.getRepeatedSfixed64(1));
+ msg.clearRepeatedSfixed64();
+ assertEquals(0, msg.getRepeatedSfixed64Count());
+ msg.clearRepeatedSfixed64()
+ .addRepeatedSfixed64(456);
+ assertEquals(1, msg.getRepeatedSfixed64Count());
+ assertEquals(456, msg.getRepeatedSfixed64(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedSfixed64Count());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedSfixed64(123);
+ assertEquals(1, msg.getRepeatedSfixed64Count());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedSfixed64Count());
+ assertEquals(123, newMsg.getRepeatedSfixed64(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedSfixed64(123)
+ .addRepeatedSfixed64(456);
+ assertEquals(2, msg.getRepeatedSfixed64Count());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 20);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedSfixed64Count());
+ assertEquals(123, newMsg.getRepeatedSfixed64(0));
+ assertEquals(456, newMsg.getRepeatedSfixed64(1));
+ }
+
+ public void testMicroRepeatedFloat() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedFloatCount());
+ msg.addRepeatedFloat(123f);
+ assertEquals(1, msg.getRepeatedFloatCount());
+ assertTrue(123f == msg.getRepeatedFloat(0));
+ msg.addRepeatedFloat(456f);
+ assertEquals(2, msg.getRepeatedFloatCount());
+ assertTrue(123f == msg.getRepeatedFloat(0));
+ assertTrue(456f == msg.getRepeatedFloat(1));
+ msg.setRepeatedFloat(0, 789f);
+ assertEquals(2, msg.getRepeatedFloatCount());
+ assertTrue(789f == msg.getRepeatedFloat(0));
+ assertTrue(456f == msg.getRepeatedFloat(1));
+ msg.clearRepeatedFloat();
+ assertEquals(0, msg.getRepeatedFloatCount());
+ msg.clearRepeatedFloat()
+ .addRepeatedFloat(456f);
+ assertEquals(1, msg.getRepeatedFloatCount());
+ assertTrue(456f == msg.getRepeatedFloat(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedFloatCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedFloat(123f);
+ assertEquals(1, msg.getRepeatedFloatCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedFloatCount());
+ assertTrue(123f == newMsg.getRepeatedFloat(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedFloat(123f)
+ .addRepeatedFloat(456f);
+ assertEquals(2, msg.getRepeatedFloatCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 12);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedFloatCount());
+ assertTrue(123f == newMsg.getRepeatedFloat(0));
+ assertTrue(456f == newMsg.getRepeatedFloat(1));
+ }
+
+ public void testMicroRepeatedDouble() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedDoubleCount());
+ msg.addRepeatedDouble(123.0);
+ assertEquals(1, msg.getRepeatedDoubleCount());
+ assertTrue(123.0 == msg.getRepeatedDouble(0));
+ msg.addRepeatedDouble(456.0);
+ assertEquals(2, msg.getRepeatedDoubleCount());
+ assertTrue(123.0 == msg.getRepeatedDouble(0));
+ assertTrue(456.0 == msg.getRepeatedDouble(1));
+ msg.setRepeatedDouble(0, 789.0);
+ assertEquals(2, msg.getRepeatedDoubleCount());
+ assertTrue(789.0 == msg.getRepeatedDouble(0));
+ assertTrue(456.0 == msg.getRepeatedDouble(1));
+ msg.clearRepeatedDouble();
+ assertEquals(0, msg.getRepeatedDoubleCount());
+ msg.clearRepeatedDouble()
+ .addRepeatedDouble(456.0);
+ assertEquals(1, msg.getRepeatedDoubleCount());
+ assertTrue(456.0 == msg.getRepeatedDouble(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedDoubleCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedDouble(123.0);
+ assertEquals(1, msg.getRepeatedDoubleCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedDoubleCount());
+ assertTrue(123.0 == newMsg.getRepeatedDouble(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedDouble(123.0)
+ .addRepeatedDouble(456.0);
+ assertEquals(2, msg.getRepeatedDoubleCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 20);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedDoubleCount());
+ assertTrue(123.0 == newMsg.getRepeatedDouble(0));
+ assertTrue(456.0 == newMsg.getRepeatedDouble(1));
+ }
+
+ public void testMicroRepeatedBool() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedBoolCount());
+ msg.addRepeatedBool(true);
+ assertEquals(1, msg.getRepeatedBoolCount());
+ assertEquals(true, msg.getRepeatedBool(0));
+ msg.addRepeatedBool(false);
+ assertEquals(2, msg.getRepeatedBoolCount());
+ assertEquals(true, msg.getRepeatedBool(0));
+ assertEquals(false, msg.getRepeatedBool(1));
+ msg.setRepeatedBool(0, false);
+ assertEquals(2, msg.getRepeatedBoolCount());
+ assertEquals(false, msg.getRepeatedBool(0));
+ assertEquals(false, msg.getRepeatedBool(1));
+ msg.clearRepeatedBool();
+ assertEquals(0, msg.getRepeatedBoolCount());
+ msg.clearRepeatedBool()
+ .addRepeatedBool(true);
+ assertEquals(1, msg.getRepeatedBoolCount());
+ assertEquals(true, msg.getRepeatedBool(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedBoolCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedBool(false);
+ assertEquals(1, msg.getRepeatedBoolCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedBoolCount());
+ assertEquals(false, newMsg.getRepeatedBool(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedBool(true)
+ .addRepeatedBool(false);
+ assertEquals(2, msg.getRepeatedBoolCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedBoolCount());
+ assertEquals(true, newMsg.getRepeatedBool(0));
+ assertEquals(false, newMsg.getRepeatedBool(1));
+ }
+
+ public void testMicroRepeatedString() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedStringCount());
+ msg.addRepeatedString("hello");
+ assertEquals(1, msg.getRepeatedStringCount());
+ assertEquals("hello", msg.getRepeatedString(0));
+ msg.addRepeatedString("bye");
+ assertEquals(2, msg.getRepeatedStringCount());
+ assertEquals("hello", msg.getRepeatedString(0));
+ assertEquals("bye", msg.getRepeatedString(1));
+ msg.setRepeatedString(0, "boo");
+ assertEquals(2, msg.getRepeatedStringCount());
+ assertEquals("boo", msg.getRepeatedString(0));
+ assertEquals("bye", msg.getRepeatedString(1));
+ msg.clearRepeatedString();
+ assertEquals(0, msg.getRepeatedStringCount());
+ msg.clearRepeatedString()
+ .addRepeatedString("hello");
+ assertEquals(1, msg.getRepeatedStringCount());
+ assertEquals("hello", msg.getRepeatedString(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedStringCount());
+
+ // Test 1 entry and an empty string
+ msg.clear()
+ .addRepeatedString("");
+ assertEquals(1, msg.getRepeatedStringCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedStringCount());
+ assertEquals("", newMsg.getRepeatedString(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedString("hello")
+ .addRepeatedString("world");
+ assertEquals(2, msg.getRepeatedStringCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 16);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedStringCount());
+ assertEquals("hello", newMsg.getRepeatedString(0));
+ assertEquals("world", newMsg.getRepeatedString(1));
+ }
+
+ public void testMicroRepeatedBytes() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedBytesCount());
+ msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
+ assertEquals(1, msg.getRepeatedBytesCount());
+ assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
+ msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("bye"));
+ assertEquals(2, msg.getRepeatedBytesCount());
+ assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
+ assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
+ msg.setRepeatedBytes(0, ByteStringMicro.copyFromUtf8("boo"));
+ assertEquals(2, msg.getRepeatedBytesCount());
+ assertEquals("boo", msg.getRepeatedBytes(0).toStringUtf8());
+ assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
+ msg.clearRepeatedBytes();
+ assertEquals(0, msg.getRepeatedBytesCount());
+ msg.clearRepeatedBytes()
+ .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
+ assertEquals(1, msg.getRepeatedBytesCount());
+ assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
+ msg.clear();
+ assertEquals(0, msg.getRepeatedBytesCount());
+
+ // Test 1 entry and an empty byte array can be serialized
+ msg.clear()
+ .addRepeatedBytes(ByteStringMicro.copyFromUtf8(""));
+ assertEquals(1, msg.getRepeatedBytesCount());
+ assertEquals("", msg.getRepeatedBytes(0).toStringUtf8());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedBytesCount());
+ assertEquals("", newMsg.getRepeatedBytes(0).toStringUtf8());
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"))
+ .addRepeatedBytes(ByteStringMicro.copyFromUtf8("world"));
+ assertEquals(2, msg.getRepeatedBytesCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 16);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedBytesCount());
+ assertEquals("hello", newMsg.getRepeatedBytes(0).toStringUtf8());
+ assertEquals("world", newMsg.getRepeatedBytes(1).toStringUtf8());
+ }
+
+ public void testMicroRepeatedGroup() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ TestAllTypesMicro.RepeatedGroup group0 =
+ new TestAllTypesMicro.RepeatedGroup().setA(0);
+ TestAllTypesMicro.RepeatedGroup group1 =
+ new TestAllTypesMicro.RepeatedGroup().setA(1);
+ TestAllTypesMicro.RepeatedGroup group2 =
+ new TestAllTypesMicro.RepeatedGroup().setA(2);
+
+ msg.addRepeatedGroup(group0);
+ assertEquals(1, msg.getRepeatedGroupCount());
+ assertEquals(0, msg.getRepeatedGroup(0).getA());
+ msg.addRepeatedGroup(group1);
+ assertEquals(2, msg.getRepeatedGroupCount());
+ assertEquals(0, msg.getRepeatedGroup(0).getA());
+ assertEquals(1, msg.getRepeatedGroup(1).getA());
+ msg.setRepeatedGroup(0, group2);
+ assertEquals(2, msg.getRepeatedGroupCount());
+ assertEquals(2, msg.getRepeatedGroup(0).getA());
+ assertEquals(1, msg.getRepeatedGroup(1).getA());
+ msg.clearRepeatedGroup();
+ assertEquals(0, msg.getRepeatedGroupCount());
+ msg.clearRepeatedGroup()
+ .addRepeatedGroup(group1);
+ assertEquals(1, msg.getRepeatedGroupCount());
+ assertEquals(1, msg.getRepeatedGroup(0).getA());
+ msg.clear();
+ assertEquals(0, msg.getRepeatedGroupCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedGroup(group0);
+ assertEquals(1, msg.getRepeatedGroupCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 7);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedGroupCount());
+ assertEquals(0, newMsg.getRepeatedGroup(0).getA());
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedGroup(group0)
+ .addRepeatedGroup(group1);
+ assertEquals(2, msg.getRepeatedGroupCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 14);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedGroupCount());
+ assertEquals(0, newMsg.getRepeatedGroup(0).getA());
+ assertEquals(1, newMsg.getRepeatedGroup(1).getA());
+ }
+
+
+ public void testMicroRepeatedNestedMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ TestAllTypesMicro.NestedMessage nestedMsg0 =
+ new TestAllTypesMicro.NestedMessage().setBb(0);
+ TestAllTypesMicro.NestedMessage nestedMsg1 =
+ new TestAllTypesMicro.NestedMessage().setBb(1);
+ TestAllTypesMicro.NestedMessage nestedMsg2 =
+ new TestAllTypesMicro.NestedMessage().setBb(2);
+
+ msg.addRepeatedNestedMessage(nestedMsg0);
+ assertEquals(1, msg.getRepeatedNestedMessageCount());
+ assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
+ msg.addRepeatedNestedMessage(nestedMsg1);
+ assertEquals(2, msg.getRepeatedNestedMessageCount());
+ assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
+ assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
+ msg.setRepeatedNestedMessage(0, nestedMsg2);
+ assertEquals(2, msg.getRepeatedNestedMessageCount());
+ assertEquals(2, msg.getRepeatedNestedMessage(0).getBb());
+ assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
+ msg.clearRepeatedNestedMessage();
+ assertEquals(0, msg.getRepeatedNestedMessageCount());
+ msg.clearRepeatedNestedMessage()
+ .addRepeatedNestedMessage(nestedMsg1);
+ assertEquals(1, msg.getRepeatedNestedMessageCount());
+ assertEquals(1, msg.getRepeatedNestedMessage(0).getBb());
+ msg.clear();
+ assertEquals(0, msg.getRepeatedNestedMessageCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedNestedMessage(nestedMsg0);
+ assertEquals(1, msg.getRepeatedNestedMessageCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedNestedMessageCount());
+ assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedNestedMessage(nestedMsg0)
+ .addRepeatedNestedMessage(nestedMsg1);
+ assertEquals(2, msg.getRepeatedNestedMessageCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedNestedMessageCount());
+ assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
+ assertEquals(1, newMsg.getRepeatedNestedMessage(1).getBb());
+ }
+
+ public void testMicroRepeatedForeignMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ MicroOuterClass.ForeignMessageMicro foreignMsg0 =
+ new MicroOuterClass.ForeignMessageMicro().setC(0);
+ MicroOuterClass.ForeignMessageMicro foreignMsg1 =
+ new MicroOuterClass.ForeignMessageMicro().setC(1);
+ MicroOuterClass.ForeignMessageMicro foreignMsg2 =
+ new MicroOuterClass.ForeignMessageMicro().setC(2);
+
+ msg.addRepeatedForeignMessage(foreignMsg0);
+ assertEquals(1, msg.getRepeatedForeignMessageCount());
+ assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
+ msg.addRepeatedForeignMessage(foreignMsg1);
+ assertEquals(2, msg.getRepeatedForeignMessageCount());
+ assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
+ assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
+ msg.setRepeatedForeignMessage(0, foreignMsg2);
+ assertEquals(2, msg.getRepeatedForeignMessageCount());
+ assertEquals(2, msg.getRepeatedForeignMessage(0).getC());
+ assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
+ msg.clearRepeatedForeignMessage();
+ assertEquals(0, msg.getRepeatedForeignMessageCount());
+ msg.clearRepeatedForeignMessage()
+ .addRepeatedForeignMessage(foreignMsg1);
+ assertEquals(1, msg.getRepeatedForeignMessageCount());
+ assertEquals(1, msg.getRepeatedForeignMessage(0).getC());
+ msg.clear();
+ assertEquals(0, msg.getRepeatedForeignMessageCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedForeignMessage(foreignMsg0);
+ assertEquals(1, msg.getRepeatedForeignMessageCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedForeignMessageCount());
+ assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedForeignMessage(foreignMsg0)
+ .addRepeatedForeignMessage(foreignMsg1);
+ assertEquals(2, msg.getRepeatedForeignMessageCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedForeignMessageCount());
+ assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
+ assertEquals(1, newMsg.getRepeatedForeignMessage(1).getC());
+ }
+
+ public void testMicroRepeatedImportMessage() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ UnittestImportMicro.ImportMessageMicro importMsg0 =
+ new UnittestImportMicro.ImportMessageMicro().setD(0);
+ UnittestImportMicro.ImportMessageMicro importMsg1 =
+ new UnittestImportMicro.ImportMessageMicro().setD(1);
+ UnittestImportMicro.ImportMessageMicro importMsg2 =
+ new UnittestImportMicro.ImportMessageMicro().setD(2);
+
+ msg.addRepeatedImportMessage(importMsg0);
+ assertEquals(1, msg.getRepeatedImportMessageCount());
+ assertEquals(0, msg.getRepeatedImportMessage(0).getD());
+ msg.addRepeatedImportMessage(importMsg1);
+ assertEquals(2, msg.getRepeatedImportMessageCount());
+ assertEquals(0, msg.getRepeatedImportMessage(0).getD());
+ assertEquals(1, msg.getRepeatedImportMessage(1).getD());
+ msg.setRepeatedImportMessage(0, importMsg2);
+ assertEquals(2, msg.getRepeatedImportMessageCount());
+ assertEquals(2, msg.getRepeatedImportMessage(0).getD());
+ assertEquals(1, msg.getRepeatedImportMessage(1).getD());
+ msg.clearRepeatedImportMessage();
+ assertEquals(0, msg.getRepeatedImportMessageCount());
+ msg.clearRepeatedImportMessage()
+ .addRepeatedImportMessage(importMsg1);
+ assertEquals(1, msg.getRepeatedImportMessageCount());
+ assertEquals(1, msg.getRepeatedImportMessage(0).getD());
+ msg.clear();
+ assertEquals(0, msg.getRepeatedImportMessageCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedImportMessage(importMsg0);
+ assertEquals(1, msg.getRepeatedImportMessageCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 5);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedImportMessageCount());
+ assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedImportMessage(importMsg0)
+ .addRepeatedImportMessage(importMsg1);
+ assertEquals(2, msg.getRepeatedImportMessageCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 10);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedImportMessageCount());
+ assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
+ assertEquals(1, newMsg.getRepeatedImportMessage(1).getD());
+ }
+
+ public void testMicroRepeatedNestedEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.addRepeatedNestedEnum(TestAllTypesMicro.FOO);
+ assertEquals(1, msg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
+ msg.addRepeatedNestedEnum(TestAllTypesMicro.BAR);
+ assertEquals(2, msg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
+ assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
+ msg.setRepeatedNestedEnum(0, TestAllTypesMicro.BAZ);
+ assertEquals(2, msg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.BAZ, msg.getRepeatedNestedEnum(0));
+ assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
+ msg.clearRepeatedNestedEnum();
+ assertEquals(0, msg.getRepeatedNestedEnumCount());
+ msg.clearRepeatedNestedEnum()
+ .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
+ assertEquals(1, msg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedNestedEnumCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedNestedEnum(TestAllTypesMicro.FOO);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedNestedEnum(TestAllTypesMicro.FOO)
+ .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
+ assertEquals(2, msg.getRepeatedNestedEnumCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedNestedEnumCount());
+ assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
+ assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
+ }
+
+ public void testMicroRepeatedForeignEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
+ assertEquals(1, msg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
+ msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
+ assertEquals(2, msg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
+ msg.setRepeatedForeignEnum(0, MicroOuterClass.FOREIGN_MICRO_BAZ);
+ assertEquals(2, msg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAZ, msg.getRepeatedForeignEnum(0));
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
+ msg.clearRepeatedForeignEnum();
+ assertEquals(0, msg.getRepeatedForeignEnumCount());
+ msg.clearRepeatedForeignEnum()
+ .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
+ assertEquals(1, msg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedForeignEnumCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO)
+ .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
+ assertEquals(2, msg.getRepeatedForeignEnumCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedForeignEnumCount());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
+ }
+
+ public void testMicroRepeatedImportEnum() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
+ assertEquals(1, msg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
+ msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
+ assertEquals(2, msg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
+ msg.setRepeatedImportEnum(0, UnittestImportMicro.IMPORT_MICRO_BAZ);
+ assertEquals(2, msg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAZ, msg.getRepeatedImportEnum(0));
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
+ msg.clearRepeatedImportEnum();
+ assertEquals(0, msg.getRepeatedImportEnumCount());
+ msg.clearRepeatedImportEnum()
+ .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
+ assertEquals(1, msg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedImportEnumCount());
+
+ // Test 1 entry
+ msg.clear()
+ .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO)
+ .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
+ assertEquals(2, msg.getRepeatedImportEnumCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 6);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedImportEnumCount());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
+ }
+
+ public void testMicroRepeatedStringPiece() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedStringPieceCount());
+ msg.addRepeatedStringPiece("hello");
+ assertEquals(1, msg.getRepeatedStringPieceCount());
+ assertEquals("hello", msg.getRepeatedStringPiece(0));
+ msg.addRepeatedStringPiece("bye");
+ assertEquals(2, msg.getRepeatedStringPieceCount());
+ assertEquals("hello", msg.getRepeatedStringPiece(0));
+ assertEquals("bye", msg.getRepeatedStringPiece(1));
+ msg.setRepeatedStringPiece(0, "boo");
+ assertEquals(2, msg.getRepeatedStringPieceCount());
+ assertEquals("boo", msg.getRepeatedStringPiece(0));
+ assertEquals("bye", msg.getRepeatedStringPiece(1));
+ msg.clearRepeatedStringPiece();
+ assertEquals(0, msg.getRepeatedStringPieceCount());
+ msg.clearRepeatedStringPiece()
+ .addRepeatedStringPiece("hello");
+ assertEquals(1, msg.getRepeatedStringPieceCount());
+ assertEquals("hello", msg.getRepeatedStringPiece(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedStringPieceCount());
+
+ // Test 1 entry and an empty string
+ msg.clear()
+ .addRepeatedStringPiece("");
+ assertEquals(1, msg.getRepeatedStringPieceCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedStringPieceCount());
+ assertEquals("", newMsg.getRepeatedStringPiece(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedStringPiece("hello")
+ .addRepeatedStringPiece("world");
+ assertEquals(2, msg.getRepeatedStringPieceCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 16);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedStringPieceCount());
+ assertEquals("hello", newMsg.getRepeatedStringPiece(0));
+ assertEquals("world", newMsg.getRepeatedStringPiece(1));
+ }
+
+ public void testMicroRepeatedCord() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertEquals(0, msg.getRepeatedCordCount());
+ msg.addRepeatedCord("hello");
+ assertEquals(1, msg.getRepeatedCordCount());
+ assertEquals("hello", msg.getRepeatedCord(0));
+ msg.addRepeatedCord("bye");
+ assertEquals(2, msg.getRepeatedCordCount());
+ assertEquals("hello", msg.getRepeatedCord(0));
+ assertEquals("bye", msg.getRepeatedCord(1));
+ msg.setRepeatedCord(0, "boo");
+ assertEquals(2, msg.getRepeatedCordCount());
+ assertEquals("boo", msg.getRepeatedCord(0));
+ assertEquals("bye", msg.getRepeatedCord(1));
+ msg.clearRepeatedCord();
+ assertEquals(0, msg.getRepeatedCordCount());
+ msg.clearRepeatedCord()
+ .addRepeatedCord("hello");
+ assertEquals(1, msg.getRepeatedCordCount());
+ assertEquals("hello", msg.getRepeatedCord(0));
+ msg.clear();
+ assertEquals(0, msg.getRepeatedCordCount());
+
+ // Test 1 entry and an empty string
+ msg.clear()
+ .addRepeatedCord("");
+ assertEquals(1, msg.getRepeatedCordCount());
+ byte [] result = msg.toByteArray();
+ int msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 3);
+ assertEquals(result.length, msgSerializedSize);
+ TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(1, newMsg.getRepeatedCordCount());
+ assertEquals("", newMsg.getRepeatedCord(0));
+
+ // Test 2 entries
+ msg.clear()
+ .addRepeatedCord("hello")
+ .addRepeatedCord("world");
+ assertEquals(2, msg.getRepeatedCordCount());
+ result = msg.toByteArray();
+ msgSerializedSize = msg.getSerializedSize();
+ //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
+ assertTrue(msgSerializedSize == 16);
+ assertEquals(result.length, msgSerializedSize);
+
+ newMsg = TestAllTypesMicro.parseFrom(result);
+ assertEquals(2, newMsg.getRepeatedCordCount());
+ assertEquals("hello", newMsg.getRepeatedCord(0));
+ assertEquals("world", newMsg.getRepeatedCord(1));
+ }
+
+ public void testMicroDefaults() throws Exception {
+ TestAllTypesMicro msg = new TestAllTypesMicro();
+ assertFalse(msg.hasDefaultInt32());
+ assertEquals(41, msg.getDefaultInt32());
+ assertFalse(msg.hasDefaultInt64());
+ assertEquals(42, msg.getDefaultInt64());
+ assertFalse(msg.hasDefaultUint32());
+ assertEquals(43, msg.getDefaultUint32());
+ assertFalse(msg.hasDefaultUint64());
+ assertEquals(44, msg.getDefaultUint64());
+ assertFalse(msg.hasDefaultSint32());
+ assertEquals(-45, msg.getDefaultSint32());
+ assertFalse(msg.hasDefaultSint64());
+ assertEquals(46, msg.getDefaultSint64());
+ assertFalse(msg.hasDefaultFixed32());
+ assertEquals(47, msg.getDefaultFixed32());
+ assertFalse(msg.hasDefaultFixed64());
+ assertEquals(48, msg.getDefaultFixed64());
+ assertFalse(msg.hasDefaultSfixed32());
+ assertEquals(49, msg.getDefaultSfixed32());
+ assertFalse(msg.hasDefaultSfixed64());
+ assertEquals(-50, msg.getDefaultSfixed64());
+ assertFalse(msg.hasDefaultFloat());
+ assertTrue(51.5f == msg.getDefaultFloat());
+ assertFalse(msg.hasDefaultDouble());
+ assertTrue(52.0e3 == msg.getDefaultDouble());
+ assertFalse(msg.hasDefaultBool());
+ assertEquals(true, msg.getDefaultBool());
+ assertFalse(msg.hasDefaultString());
+ assertEquals("hello", msg.getDefaultString());
+ assertFalse(msg.hasDefaultBytes());
+ assertEquals("world", msg.getDefaultBytes().toStringUtf8());
+ assertFalse(msg.hasDefaultNestedEnum());
+ assertEquals(TestAllTypesMicro.BAR, msg.getDefaultNestedEnum());
+ assertFalse(msg.hasDefaultForeignEnum());
+ assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getDefaultForeignEnum());
+ assertFalse(msg.hasDefaultImportEnum());
+ assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getDefaultImportEnum());
+ }
+}
diff --git a/java/src/test/java/com/google/protobuf/PerfTimer.java b/java/src/test/java/com/google/protobuf/PerfTimer.java
new file mode 100644
index 0000000..d6df4ff
--- /dev/null
+++ b/java/src/test/java/com/google/protobuf/PerfTimer.java
@@ -0,0 +1,832 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.protobuf;
+
+import java.util.Arrays;
+
+/**
+ * A Performance Timing class that can be used to estimate the amount of time a
+ * sequence of code takes. The typical code sequence would be as follows:</p>
+ * <code>
+ PerfTimer pt = new PerfTimer();
+ pt.calibrate();
+ pt.timeEachAutomatically(new Runnable() = {
+ public void run() {
+ // Add code to time
+ }
+ });
+ System.out.printf("time per loop=" + pt);
+
+ * The calibrate method determines the overhead of timing the run() method and
+ * the number of times to call the run() method to have approximately 1% precision
+ * for timing. The method pt.stats() method will return a string containing some
+ * statistics tpl, il, ol, min, max, mean, median, stddev and total.
+ *
+ * tpl ::= Timer per loop
+ * min ::= minimum time one call to run() took
+ * stddev ::= Standard deviation of the collected times
+ * mean ::= the average time to call run()
+ * median ::= 1/2 the times were > than this time and 1/2 were less.
+ * total ::= Sum of the times collected.
+ * il ::= innerLoops; the number of times run() between each call to start/stop
+ * ol ::= outerLoops, the number of times start/stop was called
+ *
+ * You can also use start/stop/restart to do simple timing:
+ *
+ * pt.start();
+ * a += 1;
+ * pt.stop();
+ * pt.log("time=" + pt);
+ * pt.restart();
+ * doSomething();
+ * pt.stop();
+ * System.out.printf("time=" + pt);
+ * </code>
+ *
+ * @author wink@google.com (Wink Saville)
+ */
+public class PerfTimer {
+ /** No debug */
+ public static final int DEBUG_LEVEL_NONE = 0;
+
+ /** Some debug */
+ public static final int DEBUG_LEVEL_SOME = 1;
+
+ /** All debug */
+ public static final int DEBUG_LEVEL_ALL = 2;
+
+ /** Timer ticks per microsecond */
+ private static final double TICKS_PER_MICROSECOND = 1000.0;
+
+ /** Random number generator */
+ java.util.Random rng = new java.util.Random();
+
+ /** get ticks */
+ private static long getTicks() {
+ return System.nanoTime();
+ }
+
+ /** Debug logging */
+ private static void log(String s) {
+ System.out.printf(String.format("[PerfTimer] %s\n", s));
+ }
+
+ /** Outer loops for timeEachAutomatically */
+ private static final int OUTER_LOOPS = 100;
+
+ /** Thrown if an error occurs while timing */
+ public static class PerfTimerException extends RuntimeException {
+ }
+
+ /**
+ * Calibration record
+ */
+ public static class CalibrationRec {
+ /** Runnable overhead */
+ public double mRunnableOverheadInMicros = 0.0;
+
+ /** Minimum Threshold value for timeEachAutomaticaly */
+ public double mMinThresholdInMicros = 3000.0;
+
+ /** Maximum Threshold value for timeEachAutomaticaly */
+ public double mMaxThresholdInMicros = 6000.0;
+
+ /** Desired precision in decimal digits */
+ public double mPrecisionInDecimalDigits = 2.0;
+
+ /**
+ * Default number of retries if the standard deviation ratio is too
+ * large
+ */
+ public final int mStdDevRetrys = 5;
+
+ /** Default maximum standard deviation radio */
+ public final double mMaxStdDevRatio = 0.15;
+
+ /** Number of votes looking for smallest time per loop */
+ public final int mVotes = 3;
+
+ /** Convert to string */
+ @Override
+ public String toString() {
+ return String
+ .format(
+ "oh=%.6fus minT=%.6fus maxT=%.6fus prc=%,.3f stdDevRetrys=%d maxStdDevRatio=%.2f votes=%d",
+ mRunnableOverheadInMicros, mMinThresholdInMicros,
+ mMaxThresholdInMicros, mPrecisionInDecimalDigits, mStdDevRetrys,
+ mMaxStdDevRatio, mVotes);
+ }
+ }
+
+ /**
+ * Calibration record
+ */
+ private CalibrationRec mCr;
+
+ /**
+ * Statistics calculated on the timing data.
+ */
+ public static class Stats {
+ /** Number of outer loops */
+ private int mOuterLoops;
+
+ /** Number of inner loops */
+ private int mInnerLoops;
+
+ /** Minimum time in times array */
+ private long mMin;
+
+ /** Maximum time in times array */
+ private long mMax;
+
+ /** Median value in times array */
+ private double mMedian;
+
+ /** The mean (average) of the values in times array */
+ private double mMean;
+
+ /** The standard deviation of the values in times array */
+ private double mStdDev;
+
+ private int mStdDevTooLargeCount;
+
+ /** Sum of the times in the times array */
+ private double mTotal;
+
+ /** Initialize */
+ public void init() {
+ mInnerLoops = 1;
+ mOuterLoops = 1;
+ mMin = 0;
+ mMax = 0;
+ mMedian = 0;
+ mMean = 0;
+ mStdDev = 0;
+ mStdDevTooLargeCount = 0;
+ mTotal = 0;
+ }
+
+ /** Constructor */
+ public Stats() {
+ init();
+ }
+
+ /** Set number of inner loops */
+ public void setInnerLoops(int loops) {
+ mInnerLoops = loops;
+ }
+
+ /** Get number of inner loops */
+ public int getInnerLoops() {
+ return mInnerLoops;
+ }
+
+ /** Set number of inner loops */
+ public void setOuterLoops(int loops) {
+ mOuterLoops = loops;
+ }
+
+ /** Get number of inner loops */
+ public int getOuterLoops() {
+ return mOuterLoops;
+ }
+
+ /**
+ * Minimum value of collected data in microseconds, valid after analyze.
+ */
+ public double getMinInMicros() {
+ return mMin / TICKS_PER_MICROSECOND;
+ }
+
+ /**
+ * Maximum value of collected data in microseconds, valid after analyze.
+ */
+ public double getMaxInMicros() {
+ return mMax / TICKS_PER_MICROSECOND;
+ }
+
+ /**
+ * Sum of the values of collected data in microseconds, valid after
+ * analyze.
+ */
+ public double getTotalInMicros() {
+ return mTotal / TICKS_PER_MICROSECOND;
+ }
+
+ /** Sum of the values of collected data in seconds, valid after analyze. */
+ public double getTotalInSecs() {
+ return mTotal / (TICKS_PER_MICROSECOND * 1000000.0);
+ }
+
+ /** Sum of the values of collected data in seconds, valid after analyze. */
+ public double getMeanInMicros() {
+ return mMean / TICKS_PER_MICROSECOND;
+ }
+
+ /** Median value of collected data in microseconds, valid after analyze. */
+ public double getMedianInMicros() {
+ return mMedian / TICKS_PER_MICROSECOND;
+ }
+
+ /**
+ * Standard deviation of collected data in microseconds, valid after
+ * analyze.
+ */
+ public double getStdDevInMicros() {
+ return mStdDev / TICKS_PER_MICROSECOND;
+ }
+
+ public double getStdDevRatio() {
+ return mStdDev / mMin;
+ }
+
+ /** Return true if (mStdDev / mMin) <= maxStdDevRation */
+ public boolean stdDevOk(double maxStdDevRatio) {
+ return getStdDevRatio() <= maxStdDevRatio;
+ }
+
+ /** Increment StdDevTooLargeCount */
+ public void incStdDevTooLargeCount() {
+ mStdDevTooLargeCount += 1;
+ }
+
+ /** Return number of times stdDev was not ok */
+ public int getStdDevTooLargeCount() {
+ return mStdDevTooLargeCount;
+ }
+
+ /** Return time per loop */
+ public double getTimePerLoop() {
+ return mMin / TICKS_PER_MICROSECOND / mInnerLoops;
+ }
+
+ /**
+ * Calculate the stats for the data. Note the data in the range will be
+ * sorted.
+ *
+ * @param data
+ * @param count
+ */
+ public Stats calculate(long data[], int count) {
+ if (count == 1) {
+ mMin = mMax = data[0];
+ mTotal = mMedian = mMean = data[0];
+ mStdDev = 0;
+ } else if (count > 1) {
+ Arrays.sort(data, 0, count);
+ mMin = data[0];
+ mMax = data[count - 1];
+ if ((count & 1) == 1) {
+ mMedian = data[((count + 1) / 2) - 1];
+ } else {
+ mMedian = (data[count / 2] + data[(count / 2) - 1]) / 2;
+ }
+ mTotal = 0;
+ double sumSquares = 0;
+ for (int i = 0; i < count; i++) {
+ long t = data[i];
+ mTotal += t;
+ sumSquares += t * t;
+ }
+ mMean = mTotal / count;
+ double variance = (sumSquares / count) - (mMean * mMean);
+ mStdDev = Math.pow(variance, 0.5);
+ } else {
+ init();
+ }
+ return this;
+ }
+
+ /** Convert to string */
+ @Override
+ public String toString() {
+ double timePerLoop = getTimePerLoop();
+ double stdDevPerLoop = mStdDev / TICKS_PER_MICROSECOND / mInnerLoops;
+ return String.format(
+ "tpl=%,.6fus stdDev=%,.6fus tpl/stdDev=%.2fpercent min=%,.6fus median=%,.6fus mean=%,.6fus max=%,.6fus total=%,.6fs il=%d, ol=%d tlc=%d",
+ timePerLoop, stdDevPerLoop, (stdDevPerLoop / timePerLoop) * 100, mMin
+ / TICKS_PER_MICROSECOND, mMedian / TICKS_PER_MICROSECOND, mMean
+ / TICKS_PER_MICROSECOND, mMax / TICKS_PER_MICROSECOND, mTotal
+ / (TICKS_PER_MICROSECOND * 1000000.0), mInnerLoops, mOuterLoops, mStdDevTooLargeCount);
+ }
+ }
+
+ /** Statistics */
+ private Stats mStats = new Stats();
+
+ /** Statistics of the clock precision */
+ private Stats mClockStats;
+
+ /** Number of items in times array */
+ private int mCount;
+
+ /** Array of stop - start times */
+ private long mTimes[];
+
+ /** Time of last started */
+ private long mStart;
+
+ /** Sleep a little so we don't look like a hog */
+ private void sleep() {
+ try {
+ Thread.sleep(0);
+ } catch (InterruptedException e) {
+ // Ignore exception
+ }
+ }
+
+ /** Empty Runnable used for determining overhead */
+ private Runnable mEmptyRunnable = new Runnable() {
+ public void run() {
+ }
+ };
+
+ /** Initialize */
+ private void init(int maxCount, CalibrationRec cr) {
+ mTimes = new long[maxCount];
+ mCr = cr;
+ reset();
+ }
+
+ /** Construct the stop watch */
+ public PerfTimer() {
+ init(10, new CalibrationRec());
+ }
+
+ /** Construct setting size of times array */
+ public PerfTimer(int maxCount) {
+ init(maxCount, new CalibrationRec());
+ }
+
+ /** Construct the stop watch */
+ public PerfTimer(CalibrationRec cr) {
+ init(10, cr);
+ }
+
+ /** Construct the stop watch */
+ public PerfTimer(int maxCount, CalibrationRec cr) {
+ init(maxCount, cr);
+ }
+
+ /** Reset the contents of the times array */
+ public PerfTimer reset() {
+ mCount = 0;
+ mStats.init();
+ return this;
+ }
+
+ /** Reset and then start the timer */
+ public PerfTimer restart() {
+ reset();
+ mStart = getTicks();
+ return this;
+ }
+
+ /** Start timing */
+ public PerfTimer start() {
+ mStart = getTicks();
+ return this;
+ }
+
+ /**
+ * Record the difference between start and now in the times array
+ * incrementing count. The time will be stored in the times array if the
+ * array is not full.
+ */
+ public PerfTimer stop() {
+ long stop = getTicks();
+ if (mCount < mTimes.length) {
+ mTimes[mCount++] = stop - mStart;
+ }
+ return this;
+ }
+
+ /**
+ * Time how long it takes to execute runnable.run() innerLoop number of
+ * times outerLoops number of times.
+ *
+ * @param outerLoops
+ * @param innerLoops
+ * @param runnable
+ * @return PerfTimer
+ */
+ public PerfTimer timeEach(Stats stats, int outerLoops, int innerLoops, Runnable runnable) {
+ reset();
+ resize(outerLoops);
+ stats.setOuterLoops(outerLoops);
+ stats.setInnerLoops(innerLoops);
+ for (int i = 0; i < outerLoops; i++) {
+ start();
+ for (int j = 0; j < innerLoops; j++) {
+ runnable.run();
+ }
+ stop();
+ sleep();
+ }
+ return this;
+ }
+
+ /**
+ * Time how long it takes to execute runnable.run(). Runs runnable votes
+ * times and returns the Stats of the fastest run. The actual number times
+ * that runnable.run() is executes is enough times so that it runs at least
+ * minThreadholeInMicros but not greater than maxThreadholdInMicro. This
+ * minimizes the chance that long context switches influence the result.
+ *
+ * @param votes is the number of runnable will be executed to determine
+ * fastest run
+ * @param outerLoops is the number of of times the inner loop is run
+ * @param initialInnerLoops is the initial inner loop
+ * @param maxStdDevRetrys if the maxStdDevRatio is exceeded this number of
+ * time the PerfTimerException is thrown.
+ * @param maxStdDevRatio the ratio of the standard deviation of the run and
+ * the time to run.
+ * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
+ * @param runnable is the code to test.
+ * @return Stats of the fastest run.
+ */
+ public Stats timeEachAutomatically(int votes, int outerLoops, int initialInnerLoops,
+ double minThresholdInMicros, double maxThresholdInMicros, int maxStdDevRetrys,
+ double maxStdDevRatio, int debugLevel, Runnable runnable) throws PerfTimerException {
+ Stats minStats = null;
+
+ for (int v = 0; v < votes; v++) {
+ boolean successful = false;
+ Stats stats = new Stats();
+ int innerLoops = initialInnerLoops;
+
+ /* Warm up cache */
+ timeEach(stats, outerLoops, initialInnerLoops, runnable);
+
+ for (int stdDevRetrys = 0; stdDevRetrys < maxStdDevRetrys; stdDevRetrys++) {
+ /**
+ * First time may be long enough
+ */
+ timeEach(stats, outerLoops, innerLoops, runnable);
+ analyze(stats, mTimes, outerLoops, debugLevel);
+ double innerLoopTime = stats.getMinInMicros();
+ if ((innerLoopTime >= minThresholdInMicros
+ - ((maxThresholdInMicros - minThresholdInMicros) / 2))) {
+ if (stats.stdDevOk(maxStdDevRatio)) {
+ successful = true;
+ break;
+ } else {
+ stats.incStdDevTooLargeCount();
+ if (debugLevel >= DEBUG_LEVEL_SOME) {
+ log(String.format(
+ "tea: tlc=%d StdDevRatio=%.2f > maxStdDevRatio=%.2f",
+ stats.getStdDevTooLargeCount(), stats.getStdDevRatio(),
+ maxStdDevRatio));
+ }
+ }
+ } else {
+ /**
+ * The initial number of loops is too short find the number
+ * of loops that exceeds maxThresholdInMicros. Then use a
+ * binary search to find the approriate innerLoop value that
+ * is between min/maxThreshold.
+ */
+ innerLoops *= 10;
+ int maxInnerLoops = innerLoops;
+ int minInnerLoops = 1;
+ boolean binarySearch = false;
+ for (int i = 0; i < 10; i++) {
+ timeEach(stats, outerLoops, innerLoops, runnable);
+ analyze(stats, mTimes, outerLoops, debugLevel);
+ innerLoopTime = stats.getMedianInMicros();
+ if ((innerLoopTime >= minThresholdInMicros)
+ && (innerLoopTime <= maxThresholdInMicros)) {
+ if (stats.stdDevOk(maxStdDevRatio)) {
+ successful = true;
+ break;
+ } else {
+ stats.incStdDevTooLargeCount();
+ if (debugLevel >= DEBUG_LEVEL_SOME) {
+ log(String.format(
+ "tea: tlc=%d StdDevRatio=%.2f > maxStdDevRatio=%.2f",
+ stats.getStdDevTooLargeCount(), stats.getStdDevRatio(),
+ maxStdDevRatio));
+ }
+ }
+ } else if (binarySearch) {
+ if ((innerLoopTime < minThresholdInMicros)) {
+ minInnerLoops = innerLoops;
+ } else {
+ maxInnerLoops = innerLoops;
+ }
+ innerLoops = (maxInnerLoops + minInnerLoops) / 2;
+ } else if (innerLoopTime >= maxThresholdInMicros) {
+ /* Found a too large value, change to binary search */
+ binarySearch = true;
+ maxInnerLoops = innerLoops;
+ innerLoops = (maxInnerLoops + minInnerLoops) / 2;
+ } else {
+ innerLoops *= 10;
+ }
+ }
+ if (successful) {
+ break;
+ }
+ }
+ }
+ if (!successful) {
+ /* Couldn't find the number of loops to execute */
+ throw new PerfTimerException();
+ }
+
+ /** Looking for minimum */
+ if ((minStats == null) || (minStats.getTimePerLoop() > stats.getTimePerLoop())) {
+ minStats = stats;
+ }
+ if (debugLevel >= DEBUG_LEVEL_SOME) {
+ log(String.format("minStats.getTimePerLoop=%f minStats: %s", minStats.getTimePerLoop(), minStats));
+ }
+ }
+
+ return minStats;
+ }
+
+ /**
+ * Time how long it takes to execute runnable.run() with a threshold of 1 to
+ * 10ms.
+ *
+ * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
+ * @param runnable
+ * @throws PerfTimerException
+ */
+ public Stats timeEachAutomatically(int debugLevel, Runnable runnable)
+ throws PerfTimerException {
+ mStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, 1, mCr.mMinThresholdInMicros,
+ mCr.mMaxThresholdInMicros, mCr.mStdDevRetrys, mCr.mMaxStdDevRatio, debugLevel,
+ runnable);
+ return mStats;
+ }
+
+ /**
+ * Time how long it takes to execute runnable.run() with a threshold of 1 to
+ * 10ms.
+ *
+ * @param runnable
+ * @throws PerfTimerException
+ */
+ public Stats timeEachAutomatically(Runnable runnable) throws PerfTimerException {
+ mStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, 1, mCr.mMinThresholdInMicros,
+ mCr.mMaxThresholdInMicros, mCr.mStdDevRetrys, mCr.mMaxStdDevRatio,
+ DEBUG_LEVEL_NONE, runnable);
+ return mStats;
+ }
+
+ /** Resize the times array */
+ public void resize(int maxCount) {
+ if (maxCount > mTimes.length) {
+ mTimes = new long[maxCount];
+ }
+ }
+
+ /**
+ * Analyze the data calculating the min, max, total, median, mean and
+ * stdDev. The standard deviation is calculated as sqrt(((sum of the squares
+ * of each time) / count) - mean^2)
+ * {@link "http://www.sciencebuddies.org/mentoring/project_data_analysis_variance_std_deviation.shtml"}
+ *
+ * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
+ * @return StopWatch
+ */
+ public Stats analyze(Stats stats, long data[], int count, int debugLevel) {
+ if (count > 0) {
+ if (debugLevel >= DEBUG_LEVEL_ALL) {
+ for (int j = 0; j < count; j++) {
+ log(String.format("data[%d]=%,dns", j, data[j]));
+ }
+ }
+ stats.calculate(data, count);
+ } else {
+ stats.init();
+ }
+ if (debugLevel >= DEBUG_LEVEL_SOME) {
+ log("stats: " + stats);
+ }
+ return stats;
+ }
+
+ /**
+ * Calibrate the system and set it for this PerfTimer instance
+ *
+ * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
+ * @param precisionInDecimalDigits the precision in number of decimal digits
+ */
+ public CalibrationRec calibrate(int debugLevel, double precisionInDecimalDigits)
+ throws PerfTimerException {
+ int nonZeroCount = 0;
+ Stats stats = new Stats();
+ CalibrationRec cr = new CalibrationRec();
+
+ /* initialize the precision */
+ cr.mPrecisionInDecimalDigits = precisionInDecimalDigits;
+
+ /* Warm up the cache */
+ timeEach(stats, OUTER_LOOPS, 10, mEmptyRunnable);
+
+ /*
+ * Determine the clock stats with at least 20% non-zero unique values.
+ */
+ for (int clockStatsTries = 1; clockStatsTries < 100; clockStatsTries++) {
+ int j;
+ int i;
+ long cur;
+ long prev;
+ long min;
+
+ int innerLoops = clockStatsTries * 10;
+ timeEach(stats, OUTER_LOOPS, innerLoops, mEmptyRunnable);
+ long nonZeroValues[] = new long[mCount];
+ prev = 0;
+ for (nonZeroCount = 0, i = 0; i < mCount; i++) {
+ cur = mTimes[i];
+ if (cur > 0) {
+ nonZeroValues[nonZeroCount++] = cur;
+ }
+ }
+ if (nonZeroCount > (mCount * 0.20)) {
+ // Calculate thresholds
+ analyze(stats, nonZeroValues, nonZeroCount, debugLevel);
+ stats.calculate(nonZeroValues, nonZeroCount);
+ cr.mMinThresholdInMicros = stats.getMeanInMicros()
+ * Math.pow(10, cr.mPrecisionInDecimalDigits);
+ cr.mMaxThresholdInMicros = cr.mMinThresholdInMicros * 2;
+
+ // Set overhead to 0 and time the empty loop then set overhead.
+ cr.mRunnableOverheadInMicros = 0;
+ mClockStats = timeEachAutomatically(mCr.mVotes, OUTER_LOOPS, innerLoops,
+ cr.mMinThresholdInMicros, cr.mMaxThresholdInMicros, mCr.mStdDevRetrys,
+ mCr.mMaxStdDevRatio, debugLevel, mEmptyRunnable);
+ cr.mRunnableOverheadInMicros = mClockStats.getMinInMicros()
+ / mClockStats.getInnerLoops();
+ break;
+ }
+ nonZeroCount = 0;
+ }
+ if (nonZeroCount == 0) {
+ throw new PerfTimerException();
+ }
+ if (debugLevel >= DEBUG_LEVEL_SOME) {
+ log(String.format("calibrate X oh=%.6fus minT=%,.6fus maxT=%,.6fus stats: %s",
+ cr.mRunnableOverheadInMicros, cr.mMinThresholdInMicros,
+ cr.mMaxThresholdInMicros, stats));
+ }
+ mCr = cr;
+ return mCr;
+ }
+
+ /** Calibrate the system and set it for this PerfTimer instance */
+ public CalibrationRec calibrate(double precisionInDecimalDigits) throws PerfTimerException {
+ return calibrate(DEBUG_LEVEL_NONE, precisionInDecimalDigits);
+ }
+
+ /** Calibrate the system and set it for this PerfTimer instance */
+ public CalibrationRec calibrate() throws PerfTimerException {
+ return calibrate(DEBUG_LEVEL_NONE, mCr.mPrecisionInDecimalDigits);
+ }
+
+ /*
+ * Accessors for the private data
+ */
+
+ /** Set calibration record */
+ public void setCalibrationRec(CalibrationRec cr) {
+ mCr = cr;
+ }
+
+ /** Get calibration record */
+ public CalibrationRec getCalibrationRec() {
+ return mCr;
+ }
+
+ /** Number of samples in times array. */
+ public int getCount() {
+ return mCount;
+ }
+
+ /** Minimum value of collected data in microseconds, valid after analyze. */
+ public double getMinInMicros() {
+ return mStats.getMinInMicros();
+ }
+
+ /** Maximum value of collected data in microseconds, valid after analyze. */
+ public double getMaxInMicros() {
+ return mStats.getMaxInMicros();
+ }
+
+ /**
+ * Sum of the values of collected data in microseconds, valid after analyze.
+ */
+ public double getTotalInMicros() {
+ return mStats.getTotalInMicros();
+ }
+
+ /** Sum of the values of collected data in seconds, valid after analyze. */
+ public double getTotalInSecs() {
+ return mStats.getTotalInSecs();
+ }
+
+ /** Sum of the values of collected data in seconds, valid after analyze. */
+ public double getMeanInMicros() {
+ return mStats.getMeanInMicros();
+ }
+
+ /** Median value of collected data in microseconds, valid after analyze. */
+ public double getMedianInMicros() {
+ return mStats.getMedianInMicros();
+ }
+
+ /**
+ * Standard deviation of collected data in microseconds, valid after
+ * analyze.
+ */
+ public double getStdDevInMicros() {
+ return mStats.getStdDevInMicros();
+ }
+
+ /** The mTimes[index] value */
+ public long getTime(int index) {
+ return mTimes[index];
+ }
+
+ /** The mTimes */
+ public long[] getTimes() {
+ return mTimes;
+ }
+
+ /** @return the clock stats as measured in calibrate */
+ public Stats getClockStats() {
+ return mClockStats;
+ }
+
+ /** @return the stats */
+ public Stats getStats() {
+ return mStats;
+ }
+
+ /**
+ * Convert stats to string
+ *
+ * @param debugLevel DEBUG_LEVEL_NONE, DEBUG_LEVEL_SOME, DEBUG_LEVEL_ALL
+ */
+ public String stats(int debugLevel) {
+ int innerLoops = mStats.getInnerLoops();
+ if (mCount == 0) {
+ return String.format("%,.3fus", (getTicks() - mStart) / TICKS_PER_MICROSECOND);
+ } else {
+ if (mCount == 1) {
+ return String.format("%,.3fus", getTime());
+ } else {
+ analyze(mStats, mTimes, mCount, debugLevel);
+ return mStats.toString();
+ }
+ }
+ }
+
+ /**
+ * Convert string
+ */
+ public String stats() {
+ return stats(0);
+ }
+
+ /**
+ * Get time
+ */
+ public double getTime() {
+ int innerLoops = mStats.getInnerLoops();
+ if (mCount == 0) {
+ return (getTicks() - mStart) / TICKS_PER_MICROSECOND;
+ } else {
+ if (mCount == 1) {
+ return mStats.getTotalInMicros();
+ } else {
+ analyze(mStats, mTimes, mCount, DEBUG_LEVEL_NONE);
+ return (mStats.getMinInMicros() / innerLoops) - mCr.mRunnableOverheadInMicros;
+ }
+ }
+ }
+
+ /** Convert to string */
+ @Override
+ public String toString() {
+ return String.format("%,.3fus", getTime());
+ }
+}
diff --git a/src/Makefile.am b/src/Makefile.am
index 35f5c0c..de83a4e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -72,6 +72,7 @@
google/protobuf/compiler/plugin.pb.h \
google/protobuf/compiler/cpp/cpp_generator.h \
google/protobuf/compiler/java/java_generator.h \
+ google/protobuf/compiler/javamicro/javamicro_generator.h \
google/protobuf/compiler/python/python_generator.h
lib_LTLIBRARIES = libprotobuf-lite.la libprotobuf.la libprotoc.la
@@ -178,6 +179,23 @@
google/protobuf/compiler/java/java_primitive_field.h \
google/protobuf/compiler/java/java_service.cc \
google/protobuf/compiler/java/java_service.h \
+ google/protobuf/compiler/javamicro/javamicro_enum.cc \
+ google/protobuf/compiler/javamicro/javamicro_enum.h \
+ google/protobuf/compiler/javamicro/javamicro_enum_field.cc \
+ google/protobuf/compiler/javamicro/javamicro_enum_field.h \
+ google/protobuf/compiler/javamicro/javamicro_field.cc \
+ google/protobuf/compiler/javamicro/javamicro_field.h \
+ google/protobuf/compiler/javamicro/javamicro_file.cc \
+ google/protobuf/compiler/javamicro/javamicro_file.h \
+ google/protobuf/compiler/javamicro/javamicro_generator.cc \
+ google/protobuf/compiler/javamicro/javamicro_helpers.cc \
+ google/protobuf/compiler/javamicro/javamicro_helpers.h \
+ google/protobuf/compiler/javamicro/javamicro_message.cc \
+ google/protobuf/compiler/javamicro/javamicro_message.h \
+ google/protobuf/compiler/javamicro/javamicro_message_field.cc\
+ google/protobuf/compiler/javamicro/javamicro_message_field.h \
+ google/protobuf/compiler/javamicro/javamicro_primitive_field.cc\
+ google/protobuf/compiler/javamicro/javamicro_primitive_field.h\
google/protobuf/compiler/python/python_generator.cc
bin_PROGRAMS = protoc
diff --git a/src/Makefile.in b/src/Makefile.in
index daf81af..b48721f 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -106,7 +106,11 @@
cpp_string_field.lo java_enum.lo java_enum_field.lo \
java_extension.lo java_field.lo java_file.lo java_generator.lo \
java_helpers.lo java_message.lo java_message_field.lo \
- java_primitive_field.lo java_service.lo python_generator.lo
+ java_primitive_field.lo java_service.lo javamicro_enum.lo \
+ javamicro_enum_field.lo javamicro_field.lo javamicro_file.lo \
+ javamicro_generator.lo javamicro_helpers.lo \
+ javamicro_message.lo javamicro_message_field.lo \
+ javamicro_primitive_field.lo python_generator.lo
libprotoc_la_OBJECTS = $(am_libprotoc_la_OBJECTS)
libprotoc_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
@@ -298,6 +302,7 @@
google/protobuf/compiler/plugin.pb.h \
google/protobuf/compiler/cpp/cpp_generator.h \
google/protobuf/compiler/java/java_generator.h \
+ google/protobuf/compiler/javamicro/javamicro_generator.h \
google/protobuf/compiler/python/python_generator.h
nobase_includeHEADERS_INSTALL = $(install_sh_DATA)
HEADERS = $(nobase_include_HEADERS)
@@ -491,6 +496,7 @@
google/protobuf/compiler/plugin.pb.h \
google/protobuf/compiler/cpp/cpp_generator.h \
google/protobuf/compiler/java/java_generator.h \
+ google/protobuf/compiler/javamicro/javamicro_generator.h \
google/protobuf/compiler/python/python_generator.h
lib_LTLIBRARIES = libprotobuf-lite.la libprotobuf.la libprotoc.la
@@ -596,6 +602,23 @@
google/protobuf/compiler/java/java_primitive_field.h \
google/protobuf/compiler/java/java_service.cc \
google/protobuf/compiler/java/java_service.h \
+ google/protobuf/compiler/javamicro/javamicro_enum.cc \
+ google/protobuf/compiler/javamicro/javamicro_enum.h \
+ google/protobuf/compiler/javamicro/javamicro_enum_field.cc \
+ google/protobuf/compiler/javamicro/javamicro_enum_field.h \
+ google/protobuf/compiler/javamicro/javamicro_field.cc \
+ google/protobuf/compiler/javamicro/javamicro_field.h \
+ google/protobuf/compiler/javamicro/javamicro_file.cc \
+ google/protobuf/compiler/javamicro/javamicro_file.h \
+ google/protobuf/compiler/javamicro/javamicro_generator.cc \
+ google/protobuf/compiler/javamicro/javamicro_helpers.cc \
+ google/protobuf/compiler/javamicro/javamicro_helpers.h \
+ google/protobuf/compiler/javamicro/javamicro_message.cc \
+ google/protobuf/compiler/javamicro/javamicro_message.h \
+ google/protobuf/compiler/javamicro/javamicro_message_field.cc\
+ google/protobuf/compiler/javamicro/javamicro_message_field.h \
+ google/protobuf/compiler/javamicro/javamicro_primitive_field.cc\
+ google/protobuf/compiler/javamicro/javamicro_primitive_field.h\
google/protobuf/compiler/python/python_generator.cc
protoc_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la
@@ -925,6 +948,15 @@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/java_message_field.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/java_primitive_field.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/java_service.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_enum.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_enum_field.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_field.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_file.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_generator.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_helpers.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_message.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_message_field.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/javamicro_primitive_field.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/message.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/message_lite.Plo@am__quote@
@@ -1467,6 +1499,69 @@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o java_service.lo `test -f 'google/protobuf/compiler/java/java_service.cc' || echo '$(srcdir)/'`google/protobuf/compiler/java/java_service.cc
+javamicro_enum.lo: google/protobuf/compiler/javamicro/javamicro_enum.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_enum.lo -MD -MP -MF $(DEPDIR)/javamicro_enum.Tpo -c -o javamicro_enum.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_enum.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_enum.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_enum.Tpo $(DEPDIR)/javamicro_enum.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_enum.cc' object='javamicro_enum.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_enum.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_enum.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_enum.cc
+
+javamicro_enum_field.lo: google/protobuf/compiler/javamicro/javamicro_enum_field.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_enum_field.lo -MD -MP -MF $(DEPDIR)/javamicro_enum_field.Tpo -c -o javamicro_enum_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_enum_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_enum_field.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_enum_field.Tpo $(DEPDIR)/javamicro_enum_field.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_enum_field.cc' object='javamicro_enum_field.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_enum_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_enum_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_enum_field.cc
+
+javamicro_field.lo: google/protobuf/compiler/javamicro/javamicro_field.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_field.lo -MD -MP -MF $(DEPDIR)/javamicro_field.Tpo -c -o javamicro_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_field.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_field.Tpo $(DEPDIR)/javamicro_field.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_field.cc' object='javamicro_field.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_field.cc
+
+javamicro_file.lo: google/protobuf/compiler/javamicro/javamicro_file.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_file.lo -MD -MP -MF $(DEPDIR)/javamicro_file.Tpo -c -o javamicro_file.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_file.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_file.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_file.Tpo $(DEPDIR)/javamicro_file.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_file.cc' object='javamicro_file.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_file.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_file.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_file.cc
+
+javamicro_generator.lo: google/protobuf/compiler/javamicro/javamicro_generator.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_generator.lo -MD -MP -MF $(DEPDIR)/javamicro_generator.Tpo -c -o javamicro_generator.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_generator.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_generator.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_generator.Tpo $(DEPDIR)/javamicro_generator.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_generator.cc' object='javamicro_generator.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_generator.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_generator.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_generator.cc
+
+javamicro_helpers.lo: google/protobuf/compiler/javamicro/javamicro_helpers.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_helpers.lo -MD -MP -MF $(DEPDIR)/javamicro_helpers.Tpo -c -o javamicro_helpers.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_helpers.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_helpers.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_helpers.Tpo $(DEPDIR)/javamicro_helpers.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_helpers.cc' object='javamicro_helpers.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_helpers.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_helpers.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_helpers.cc
+
+javamicro_message.lo: google/protobuf/compiler/javamicro/javamicro_message.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_message.lo -MD -MP -MF $(DEPDIR)/javamicro_message.Tpo -c -o javamicro_message.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_message.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_message.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_message.Tpo $(DEPDIR)/javamicro_message.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_message.cc' object='javamicro_message.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_message.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_message.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_message.cc
+
+javamicro_message_field.lo: google/protobuf/compiler/javamicro/javamicro_message_field.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_message_field.lo -MD -MP -MF $(DEPDIR)/javamicro_message_field.Tpo -c -o javamicro_message_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_message_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_message_field.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_message_field.Tpo $(DEPDIR)/javamicro_message_field.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_message_field.cc' object='javamicro_message_field.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_message_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_message_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_message_field.cc
+
+javamicro_primitive_field.lo: google/protobuf/compiler/javamicro/javamicro_primitive_field.cc
+@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT javamicro_primitive_field.lo -MD -MP -MF $(DEPDIR)/javamicro_primitive_field.Tpo -c -o javamicro_primitive_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_primitive_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_primitive_field.cc
+@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/javamicro_primitive_field.Tpo $(DEPDIR)/javamicro_primitive_field.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='google/protobuf/compiler/javamicro/javamicro_primitive_field.cc' object='javamicro_primitive_field.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o javamicro_primitive_field.lo `test -f 'google/protobuf/compiler/javamicro/javamicro_primitive_field.cc' || echo '$(srcdir)/'`google/protobuf/compiler/javamicro/javamicro_primitive_field.cc
+
python_generator.lo: google/protobuf/compiler/python/python_generator.cc
@am__fastdepCXX_TRUE@ $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT python_generator.lo -MD -MP -MF $(DEPDIR)/python_generator.Tpo -c -o python_generator.lo `test -f 'google/protobuf/compiler/python/python_generator.cc' || echo '$(srcdir)/'`google/protobuf/compiler/python/python_generator.cc
@am__fastdepCXX_TRUE@ mv -f $(DEPDIR)/python_generator.Tpo $(DEPDIR)/python_generator.Plo
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_enum.cc b/src/google/protobuf/compiler/javamicro/javamicro_enum.cc
new file mode 100644
index 0000000..d74a149
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_enum.cc
@@ -0,0 +1,96 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <map>
+#include <string>
+
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/compiler/javamicro/javamicro_enum.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+EnumGenerator::EnumGenerator(const EnumDescriptor* descriptor, const Params& params)
+ : params_(params), descriptor_(descriptor) {
+ for (int i = 0; i < descriptor_->value_count(); i++) {
+ const EnumValueDescriptor* value = descriptor_->value(i);
+ const EnumValueDescriptor* canonical_value =
+ descriptor_->FindValueByNumber(value->number());
+
+ if (value == canonical_value) {
+ canonical_values_.push_back(value);
+ } else {
+ Alias alias;
+ alias.value = value;
+ alias.canonical_value = canonical_value;
+ aliases_.push_back(alias);
+ }
+ }
+}
+
+EnumGenerator::~EnumGenerator() {}
+
+void EnumGenerator::Generate(io::Printer* printer) {
+ printer->Print("// enum $classname$\n", "classname", descriptor_->name());
+ for (int i = 0; i < canonical_values_.size(); i++) {
+ map<string, string> vars;
+ vars["name"] = canonical_values_[i]->name();
+ vars["canonical_value"] = SimpleItoa(canonical_values_[i]->number());
+ printer->Print(vars,
+ "public static final int $name$ = $canonical_value$;\n");
+ }
+
+ // -----------------------------------------------------------------
+
+ for (int i = 0; i < aliases_.size(); i++) {
+ map<string, string> vars;
+ vars["name"] = aliases_[i].value->name();
+ vars["canonical_name"] = aliases_[i].canonical_value->name();
+ printer->Print(vars,
+ "public static final int $name$ = $canonical_name$;\n");
+ }
+
+ printer->Print("\n");
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_enum.h b/src/google/protobuf/compiler/javamicro/javamicro_enum.h
new file mode 100644
index 0000000..9cf226f
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_enum.h
@@ -0,0 +1,87 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_H__
+
+#include <string>
+#include <vector>
+
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+ namespace io {
+ class Printer; // printer.h
+ }
+}
+
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class EnumGenerator {
+ public:
+ explicit EnumGenerator(const EnumDescriptor* descriptor, const Params& params);
+ ~EnumGenerator();
+
+ void Generate(io::Printer* printer);
+
+ private:
+ const Params& params_;
+ const EnumDescriptor* descriptor_;
+
+ // The proto language allows multiple enum constants to have the same numeric
+ // value. Java, however, does not allow multiple enum constants to be
+ // considered equivalent. We treat the first defined constant for any
+ // given numeric value as "canonical" and the rest as aliases of that
+ // canonical value.
+ vector<const EnumValueDescriptor*> canonical_values_;
+
+ struct Alias {
+ const EnumValueDescriptor* value;
+ const EnumValueDescriptor* canonical_value;
+ };
+ vector<Alias> aliases_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_enum_field.cc b/src/google/protobuf/compiler/javamicro/javamicro_enum_field.cc
new file mode 100644
index 0000000..0ff49a3
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_enum_field.cc
@@ -0,0 +1,333 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <map>
+#include <string>
+
+#include <google/protobuf/compiler/javamicro/javamicro_enum_field.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/wire_format.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+namespace {
+
+// TODO(kenton): Factor out a "SetCommonFieldVariables()" to get rid of
+// repeat code between this and the other field types.
+void SetEnumVariables(const Params& params,
+ const FieldDescriptor* descriptor, map<string, string>* variables) {
+ (*variables)["name"] =
+ UnderscoresToCamelCase(descriptor);
+ (*variables)["capitalized_name"] =
+ UnderscoresToCapitalizedCamelCase(descriptor);
+ (*variables)["number"] = SimpleItoa(descriptor->number());
+ (*variables)["type"] = "int";
+ (*variables)["default"] = DefaultValue(params, descriptor);
+ (*variables)["tag"] = SimpleItoa(internal::WireFormat::MakeTag(descriptor));
+ (*variables)["tag_size"] = SimpleItoa(
+ internal::WireFormat::TagSize(descriptor->number(), descriptor->type()));
+ (*variables)["message_name"] = descriptor->containing_type()->name();
+}
+
+} // namespace
+
+// ===================================================================
+
+EnumFieldGenerator::
+EnumFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetEnumVariables(params, descriptor, &variables_);
+}
+
+EnumFieldGenerator::~EnumFieldGenerator() {}
+
+void EnumFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ printer->Print(variables_,
+ "private boolean has$capitalized_name$;\n"
+ "private int $name$_ = $default$;\n"
+ "public boolean has$capitalized_name$() { return has$capitalized_name$; }\n"
+ "public int get$capitalized_name$() { return $name$_; }\n"
+ "public $message_name$ set$capitalized_name$(int value) {\n"
+ " has$capitalized_name$ = true;\n"
+ " $name$_ = value;\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " has$capitalized_name$ = false;\n"
+ " $name$_ = $default$;\n"
+ " return this;\n"
+ "}\n");
+}
+
+void EnumFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "what is other??"
+ "if (other.has$capitalized_name$()) {\n"
+ " set$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
+}
+
+void EnumFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ " set$capitalized_name$(input.readInt32());\n");
+}
+
+void EnumFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " output.writeInt32($number$, get$capitalized_name$());\n"
+ "}\n");
+}
+
+void EnumFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeInt32Size($number$, get$capitalized_name$());\n"
+ "}\n");
+}
+
+string EnumFieldGenerator::GetBoxedType() const {
+ return ClassName(params_, descriptor_->enum_type());
+}
+
+// ===================================================================
+
+RepeatedEnumFieldGenerator::
+RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetEnumVariables(params, descriptor, &variables_);
+ if (descriptor_->options().packed()) {
+ GOOGLE_LOG(FATAL) << "MicroRuntime does not support packed";
+ }
+}
+
+RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {}
+
+void RepeatedEnumFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "private java.util.Vector $name$_ = new java.util.Vector();\n"
+ "public java.util.Vector get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public int get$capitalized_name$(int index) {\n"
+ " return ((Integer)$name$_.elementAt(index)).intValue();\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, int value) {\n"
+ " $name$_.setElementAt(new Integer(value), index);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$(int value) {\n"
+ " $name$_.addElement(new Integer(value));\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_.removeAllElements();\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "private java.util.List<Integer> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
+ "public java.util.List<Integer> get$capitalized_name$List() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public int get$capitalized_name$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, int value) {\n"
+ " $name$_.set(index, value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$(int value) {\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
+ " }\n"
+ " $name$_.add(value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_ = java.util.Collections.emptyList();\n"
+ " return this;\n"
+ "}\n");
+ }
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "private int $name$MemoizedSerializedSize;\n");
+ }
+}
+
+void RepeatedEnumFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "if (other.$name$_.size() != 0) {\n"
+ " for (int i = 0; i < other.$name$_.size(); i++)) {\n"
+ " result.$name$_.addElement(other.$name$_.elementAt(i));\n"
+ " }\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if (result.$name$_.isEmpty()) {\n"
+ " result.$name$_ = new java.util.ArrayList<java.lang.Integer>();\n"
+ " }\n"
+ " result.$name$_.addAll(other.$name$_);\n"
+ "}\n");
+ }
+}
+
+void RepeatedEnumFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ // If packed, set up the while loop
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "int length = input.readRawVarint32();\n"
+ "int oldLimit = input.pushLimit(length);\n"
+ "while(input.getBytesUntilLimit() > 0) {\n");
+ printer->Indent();
+ }
+
+ // Read and store the enum
+ printer->Print(variables_,
+ " add$capitalized_name$(input.readInt32());\n");
+
+ if (descriptor_->options().packed()) {
+ printer->Outdent();
+ printer->Print(variables_,
+ "}\n"
+ "input.popLimit(oldLimit);\n");
+ }
+}
+
+void RepeatedEnumFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "if (get$capitalized_name$List().size() > 0) {\n"
+ " output.writeRawVarint32($tag$);\n"
+ " output.writeRawVarint32($name$MemoizedSerializedSize);\n"
+ "}\n");
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.writeRawVarint32(get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " output.writeRawVarint32(element.getNumber());\n"
+ "}\n");
+ }
+ } else {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.writeInt32($number$, (int)get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for (java.lang.Integer element : get$capitalized_name$List()) {\n"
+ " output.writeInt32($number$, element);\n"
+ "}\n");
+ }
+ }
+}
+
+void RepeatedEnumFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "{\n"
+ " int dataSize = 0;\n");
+ printer->Indent();
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " dataSize += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeInt32SizeNoTag(get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for (java.lang.Integer element : get$capitalized_name$List()) {\n"
+ " dataSize += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeInt32SizeNoTag(element);\n"
+ "}\n");
+ }
+ printer->Print(
+ "size += dataSize;\n");
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "if (get$capitalized_name$List().size() != 0) {"
+ " size += $tag_size$;\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeRawVarint32Size(dataSize);\n"
+ "}");
+ } else {
+ printer->Print(variables_,
+ "size += $tag_size$ * get$capitalized_name$List().size();\n");
+ }
+
+ // cache the data size for packed fields.
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "$name$MemoizedSerializedSize = dataSize;\n");
+ }
+
+ printer->Outdent();
+ printer->Print("}\n");
+}
+
+string RepeatedEnumFieldGenerator::GetBoxedType() const {
+ return ClassName(params_, descriptor_->enum_type());
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_enum_field.h b/src/google/protobuf/compiler/javamicro/javamicro_enum_field.h
new file mode 100644
index 0000000..ab671c1
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_enum_field.h
@@ -0,0 +1,94 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_FIELD_H__
+
+#include <map>
+#include <string>
+#include <google/protobuf/compiler/javamicro/javamicro_field.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class EnumFieldGenerator : public FieldGenerator {
+ public:
+ explicit EnumFieldGenerator(const FieldDescriptor* descriptor, const Params& params);
+ ~EnumFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumFieldGenerator);
+};
+
+class RepeatedEnumFieldGenerator : public FieldGenerator {
+ public:
+ explicit RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor, const Params& params);
+ ~RepeatedEnumFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedEnumFieldGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_ENUM_FIELD_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_field.cc b/src/google/protobuf/compiler/javamicro/javamicro_field.cc
new file mode 100644
index 0000000..a2ea4f9
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_field.cc
@@ -0,0 +1,102 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <google/protobuf/compiler/javamicro/javamicro_field.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/compiler/javamicro/javamicro_primitive_field.h>
+#include <google/protobuf/compiler/javamicro/javamicro_enum_field.h>
+#include <google/protobuf/compiler/javamicro/javamicro_message_field.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+FieldGenerator::~FieldGenerator() {}
+
+FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor, const Params ¶ms)
+ : descriptor_(descriptor),
+ field_generators_(
+ new scoped_ptr<FieldGenerator>[descriptor->field_count()]),
+ extension_generators_(
+ new scoped_ptr<FieldGenerator>[descriptor->extension_count()]) {
+
+ // Construct all the FieldGenerators.
+ for (int i = 0; i < descriptor->field_count(); i++) {
+ field_generators_[i].reset(MakeGenerator(descriptor->field(i), params));
+ }
+ for (int i = 0; i < descriptor->extension_count(); i++) {
+ extension_generators_[i].reset(MakeGenerator(descriptor->extension(i), params));
+ }
+}
+
+FieldGenerator* FieldGeneratorMap::MakeGenerator(const FieldDescriptor* field, const Params ¶ms) {
+ if (field->is_repeated()) {
+ switch (GetJavaType(field)) {
+ case JAVATYPE_MESSAGE:
+ return new RepeatedMessageFieldGenerator(field, params);
+ case JAVATYPE_ENUM:
+ return new RepeatedEnumFieldGenerator(field, params);
+ default:
+ return new RepeatedPrimitiveFieldGenerator(field, params);
+ }
+ } else {
+ switch (GetJavaType(field)) {
+ case JAVATYPE_MESSAGE:
+ return new MessageFieldGenerator(field, params);
+ case JAVATYPE_ENUM:
+ return new EnumFieldGenerator(field, params);
+ default:
+ return new PrimitiveFieldGenerator(field, params);
+ }
+ }
+}
+
+FieldGeneratorMap::~FieldGeneratorMap() {}
+
+const FieldGenerator& FieldGeneratorMap::get(
+ const FieldDescriptor* field) const {
+ GOOGLE_CHECK_EQ(field->containing_type(), descriptor_);
+ return *field_generators_[field->index()];
+}
+
+const FieldGenerator& FieldGeneratorMap::get_extension(int index) const {
+ return *extension_generators_[index];
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_field.h b/src/google/protobuf/compiler/javamicro/javamicro_field.h
new file mode 100644
index 0000000..1530778
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_field.h
@@ -0,0 +1,98 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_FIELD_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+
+namespace google {
+namespace protobuf {
+ namespace io {
+ class Printer; // printer.h
+ }
+}
+
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class FieldGenerator {
+ public:
+ //FieldGenerator() {}
+ FieldGenerator(const Params& params) : params_(params) {}
+ virtual ~FieldGenerator();
+
+ virtual void GenerateMembers(io::Printer* printer) const = 0;
+ virtual void GenerateMergingCode(io::Printer* printer) const = 0;
+ virtual void GenerateParsingCode(io::Printer* printer) const = 0;
+ virtual void GenerateSerializationCode(io::Printer* printer) const = 0;
+ virtual void GenerateSerializedSizeCode(io::Printer* printer) const = 0;
+
+ virtual string GetBoxedType() const = 0;
+
+ protected:
+ const Params& params_;
+ private:
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGenerator);
+};
+
+// Convenience class which constructs FieldGenerators for a Descriptor.
+class FieldGeneratorMap {
+ public:
+ explicit FieldGeneratorMap(const Descriptor* descriptor, const Params ¶ms);
+ ~FieldGeneratorMap();
+
+ const FieldGenerator& get(const FieldDescriptor* field) const;
+ const FieldGenerator& get_extension(int index) const;
+
+ private:
+ const Descriptor* descriptor_;
+ scoped_array<scoped_ptr<FieldGenerator> > field_generators_;
+ scoped_array<scoped_ptr<FieldGenerator> > extension_generators_;
+
+ static FieldGenerator* MakeGenerator(const FieldDescriptor* field, const Params ¶ms);
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGeneratorMap);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_FIELD_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_file.cc b/src/google/protobuf/compiler/javamicro/javamicro_file.cc
new file mode 100644
index 0000000..0985538
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_file.cc
@@ -0,0 +1,251 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <google/protobuf/compiler/javamicro/javamicro_file.h>
+#include <google/protobuf/compiler/javamicro/javamicro_enum.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/compiler/javamicro/javamicro_message.h>
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+namespace {
+
+// Recursively searches the given message to see if it contains any extensions.
+bool UsesExtensions(const Message& message) {
+ const Reflection* reflection = message.GetReflection();
+
+ // We conservatively assume that unknown fields are extensions.
+ if (reflection->GetUnknownFields(message).field_count() > 0) return true;
+
+ vector<const FieldDescriptor*> fields;
+ reflection->ListFields(message, &fields);
+
+ for (int i = 0; i < fields.size(); i++) {
+ if (fields[i]->is_extension()) return true;
+
+ if (fields[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+ if (fields[i]->is_repeated()) {
+ int size = reflection->FieldSize(message, fields[i]);
+ for (int j = 0; j < size; j++) {
+ const Message& sub_message =
+ reflection->GetRepeatedMessage(message, fields[i], j);
+ if (UsesExtensions(sub_message)) return true;
+ }
+ } else {
+ const Message& sub_message = reflection->GetMessage(message, fields[i]);
+ if (UsesExtensions(sub_message)) return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+} // namespace
+
+FileGenerator::FileGenerator(const FileDescriptor* file, const Params& params)
+ : file_(file),
+ params_(params),
+ java_package_(FileJavaPackage(params, file)),
+ classname_(FileClassName(params, file)) {}
+
+FileGenerator::~FileGenerator() {}
+
+bool FileGenerator::Validate(string* error) {
+ // Check for extensions
+ FileDescriptorProto file_proto;
+ file_->CopyTo(&file_proto);
+ if (UsesExtensions(file_proto)) {
+ error->assign(file_->name());
+ error->append(
+ ": Java MICRO_RUNTIME does not support extensions\"");
+ return false;
+ }
+
+ // If there is no outer class name then there must be only
+ // message and no enums defined in the file scope.
+ if (!params_.has_java_outer_classname(file_->name())) {
+ if (file_->message_type_count() != 1) {
+ error->assign(file_->name());
+ error->append(
+ ": Java MICRO_RUNTIME may only have 1 message if there is no 'option java_outer_classname'\"");
+ return false;
+ }
+
+ if (file_->enum_type_count() != 0) {
+ error->assign(file_->name());
+ error->append(
+ ": Java MICRO_RUNTIME must have an 'option java_outer_classname' if file scope enums are present\"");
+ return false;
+ }
+ }
+
+ // Check that no class name matches the file's class name. This is a common
+ // problem that leads to Java compile errors that can be hard to understand.
+ // It's especially bad when using the java_multiple_files, since we would
+ // end up overwriting the outer class with one of the inner ones.
+ int found_fileName = 0;
+ for (int i = 0; i < file_->enum_type_count(); i++) {
+ if (file_->enum_type(i)->name() == classname_) {
+ found_fileName += 1;
+ }
+ }
+ for (int i = 0; i < file_->message_type_count(); i++) {
+ if (file_->message_type(i)->name() == classname_) {
+ found_fileName += 1;
+ }
+ }
+ if (file_->service_count() != 0) {
+ error->assign(file_->name());
+ error->append(
+ ": Java MICRO_RUNTIME does not support services\"");
+ return false;
+ }
+
+ if (found_fileName > 1) {
+ error->assign(file_->name());
+ error->append(
+ ": Cannot generate Java output because there is more than one class name, \"");
+ error->append(classname_);
+ error->append(
+ "\", matches the name of one of the types declared inside it. "
+ "Please either rename the type or use the java_outer_classname "
+ "option to specify a different outer class name for the .proto file."
+ " -- FIX THIS MESSAGE");
+ return false;
+ }
+ return true;
+}
+
+void FileGenerator::Generate(io::Printer* printer) {
+ // We don't import anything because we refer to all classes by their
+ // fully-qualified names in the generated source.
+ printer->Print(
+ "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
+ "\n");
+ if (!java_package_.empty()) {
+ printer->Print(
+ "package $package$;\n"
+ "\n",
+ "package", java_package_);
+ }
+
+ if (params_.has_java_outer_classname(file_->name())) {
+ printer->Print(
+ "public final class $classname$ {\n"
+ " private $classname$() {}\n",
+ "classname", classname_);
+ printer->Indent();
+ }
+
+ // -----------------------------------------------------------------
+
+ if (!params_.java_multiple_files()) {
+ for (int i = 0; i < file_->enum_type_count(); i++) {
+ EnumGenerator(file_->enum_type(i), params_).Generate(printer);
+ }
+ for (int i = 0; i < file_->message_type_count(); i++) {
+ MessageGenerator(file_->message_type(i), params_).Generate(printer);
+ }
+ }
+
+ // Static variables.
+ for (int i = 0; i < file_->message_type_count(); i++) {
+ // TODO(kenton): Reuse MessageGenerator objects?
+ MessageGenerator(file_->message_type(i), params_).GenerateStaticVariables(printer);
+ }
+
+ if (params_.has_java_outer_classname(file_->name())) {
+ printer->Outdent();
+ printer->Print(
+ "}\n");
+ }
+}
+
+template<typename GeneratorClass, typename DescriptorClass>
+static void GenerateSibling(const string& package_dir,
+ const string& java_package,
+ const DescriptorClass* descriptor,
+ OutputDirectory* output_directory,
+ vector<string>* file_list,
+ const Params& params) {
+ string filename = package_dir + descriptor->name() + ".java";
+ file_list->push_back(filename);
+
+ scoped_ptr<io::ZeroCopyOutputStream> output(
+ output_directory->Open(filename));
+ io::Printer printer(output.get(), '$');
+
+ printer.Print(
+ "// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
+ "\n");
+ if (!java_package.empty()) {
+ printer.Print(
+ "package $package$;\n"
+ "\n",
+ "package", java_package);
+ }
+
+ GeneratorClass(descriptor, params).Generate(&printer);
+}
+
+void FileGenerator::GenerateSiblings(const string& package_dir,
+ OutputDirectory* output_directory,
+ vector<string>* file_list) {
+ if (params_.java_multiple_files()) {
+ for (int i = 0; i < file_->enum_type_count(); i++) {
+ GenerateSibling<EnumGenerator>(package_dir, java_package_,
+ file_->enum_type(i),
+ output_directory, file_list, params_);
+ }
+ for (int i = 0; i < file_->message_type_count(); i++) {
+ GenerateSibling<MessageGenerator>(package_dir, java_package_,
+ file_->message_type(i),
+ output_directory, file_list, params_);
+ }
+ }
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_file.h b/src/google/protobuf/compiler/javamicro/javamicro_file.h
new file mode 100644
index 0000000..430172a
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_file.h
@@ -0,0 +1,94 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_FILE_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_FILE_H__
+
+#include <string>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+
+namespace google {
+namespace protobuf {
+ class FileDescriptor; // descriptor.h
+ namespace io {
+ class Printer; // printer.h
+ }
+ namespace compiler {
+ class OutputDirectory; // code_generator.h
+ }
+}
+
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class FileGenerator {
+ public:
+ explicit FileGenerator(const FileDescriptor* file, const Params& params);
+ ~FileGenerator();
+
+ // Checks for problems that would otherwise lead to cryptic compile errors.
+ // Returns true if there are no problems, or writes an error description to
+ // the given string and returns false otherwise.
+ bool Validate(string* error);
+
+ void Generate(io::Printer* printer);
+
+ // If we aren't putting everything into one file, this will write all the
+ // files other than the outer file (i.e. one for each message, enum, and
+ // service type).
+ void GenerateSiblings(const string& package_dir,
+ OutputDirectory* output_directory,
+ vector<string>* file_list);
+
+ const string& java_package() { return java_package_; }
+ const string& classname() { return classname_; }
+
+ private:
+ const FileDescriptor* file_;
+ const Params& params_;
+ string java_package_;
+ string classname_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_FILE_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_generator.cc b/src/google/protobuf/compiler/javamicro/javamicro_generator.cc
new file mode 100644
index 0000000..bfba8c5
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_generator.cc
@@ -0,0 +1,209 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/compiler/javamicro/javamicro_generator.h>
+#include <google/protobuf/compiler/javamicro/javamicro_file.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+void UpdateParamsRecursively(Params& params,
+ const FileDescriptor* file) {
+ // Add any parameters for this file
+ if (file->options().has_java_outer_classname()) {
+ params.set_java_outer_classname(
+ file->name(), file->options().java_outer_classname());
+ }
+ if (file->options().has_java_package()) {
+ params.set_java_package(
+ file->name(), file->options().java_package());
+ }
+
+ // Loop through all dependent files recursively
+ // adding dep
+ for (int i = 0; i < file->dependency_count(); i++) {
+ UpdateParamsRecursively(params, file->dependency(i));
+ }
+}
+
+JavaMicroGenerator::JavaMicroGenerator() {}
+JavaMicroGenerator::~JavaMicroGenerator() {}
+
+bool JavaMicroGenerator::Generate(const FileDescriptor* file,
+ const string& parameter,
+ OutputDirectory* output_directory,
+ string* error) const {
+ vector<pair<string, string> > options;
+
+// GOOGLE_LOG(INFO) << "wink: JavaMicroGenerator::Generate INFO";
+// GOOGLE_LOG(WARNING) << "wink: JavaMicroGenerator::Generate WARNING";
+// GOOGLE_LOG(ERROR) << "wink: JavaMicroGenerator::Generate ERROR";
+// GOOGLE_LOG(FATAL) << "wink: JavaMicroGenerator::Generate";
+
+ ParseGeneratorParameter(parameter, &options);
+
+ // -----------------------------------------------------------------
+ // parse generator options
+
+ // Name a file where we will write a list of generated file names, one
+ // per line.
+ string output_list_file;
+ Params params(file->name());
+
+ // Get options from the proto file
+ if (file->options().has_java_multiple_files()) {
+ params.set_java_multiple_files(file->options().java_multiple_files());
+ }
+
+ // Update per file params
+ UpdateParamsRecursively(params, file);
+
+ // Replace any existing options with ones from command line
+ for (int i = 0; i < options.size(); i++) {
+ // GOOGLE_LOG(WARNING) << "first=" << options[i].first
+ // << " second=" << options[i].second;
+ if (options[i].first == "output_list_file") {
+ output_list_file = options[i].second;
+ } else if (options[i].first == "opt") {
+ if (options[i].second == "speed") {
+ params.set_optimization(JAVAMICRO_OPT_SPEED);
+ } else if (options[i].second == "space") {
+ params.set_optimization(JAVAMICRO_OPT_SPACE);
+ } else {
+ *error = "Unknown javamicro generator option: opt="
+ + options[i].second + " expecting opt=space or opt=speed";
+ return false;
+ }
+ } else if (options[i].first == "java_package") {
+ vector<string> parts;
+ SplitStringUsing(options[i].second, "|", &parts);
+ if (parts.size() != 2) {
+ *error = "Bad java_package, expecting filename|PackageName found '"
+ + options[i].second + "'";
+ return false;
+ }
+ params.set_java_package(parts[0], parts[1]);
+ } else if (options[i].first == "java_outer_classname") {
+ vector<string> parts;
+ SplitStringUsing(options[i].second, "|", &parts);
+ if (parts.size() != 2) {
+ *error = "Bad java_outer_classname, "
+ "expecting filename|ClassName found '"
+ + options[i].second + "'";
+ return false;
+ }
+ params.set_java_outer_classname(parts[0], parts[1]);
+ } else if (options[i].first == "java_multiple_files") {
+ params.set_java_multiple_files(options[i].second == "true");
+ } else if (options[i].first == "java_use_vector") {
+ params.set_java_use_vector(options[i].second == "true");
+ } else {
+ *error = "Ignore unknown javamicro generator option: " + options[i].first;
+ }
+ }
+
+#if 0
+ GOOGLE_LOG(WARNING) << "optimization()=" << params.optimization();
+ GOOGLE_LOG(WARNING) << "java_multiple_files()=" << params.java_multiple_files();
+ GOOGLE_LOG(WARNING) << "java_use_vector()=" << params.java_use_vector();
+
+ GOOGLE_LOG(WARNING) << "----------";
+ for (Params::NameMap::const_iterator it = params.java_packages().begin();
+ it != params.java_packages().end();
+ ++it) {
+ GOOGLE_LOG(WARNING) << "cn.filename=" << it->first << " package=" << it->second;
+ }
+ for (Params::NameMap::const_iterator it = params.java_outer_classnames().begin();
+ it != params.java_outer_classnames().end();
+ ++it) {
+ GOOGLE_LOG(WARNING) << "cn.filename=" << it->first << " classname=" << it->second;
+ }
+ GOOGLE_LOG(WARNING) << "==========";
+
+#endif
+
+ // -----------------------------------------------------------------
+
+ FileGenerator file_generator(file, params);
+ if (!file_generator.Validate(error)) {
+ return false;
+ }
+
+ string package_dir =
+ StringReplace(file_generator.java_package(), ".", "/", true);
+ if (!package_dir.empty()) package_dir += "/";
+
+ vector<string> all_files;
+
+ string java_filename = package_dir;
+ java_filename += file_generator.classname();
+ java_filename += ".java";
+ all_files.push_back(java_filename);
+
+ // Generate main java file.
+ scoped_ptr<io::ZeroCopyOutputStream> output(
+ output_directory->Open(java_filename));
+ io::Printer printer(output.get(), '$');
+ file_generator.Generate(&printer);
+
+ // Generate sibling files.
+ file_generator.GenerateSiblings(package_dir, output_directory, &all_files);
+
+ // Generate output list if requested.
+ if (!output_list_file.empty()) {
+ // Generate output list. This is just a simple text file placed in a
+ // deterministic location which lists the .java files being generated.
+ scoped_ptr<io::ZeroCopyOutputStream> srclist_raw_output(
+ output_directory->Open(output_list_file));
+ io::Printer srclist_printer(srclist_raw_output.get(), '$');
+ for (int i = 0; i < all_files.size(); i++) {
+ srclist_printer.Print("$filename$\n", "filename", all_files[i]);
+ }
+ }
+
+ return true;
+}
+
+} // namespace java
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_generator.h b/src/google/protobuf/compiler/javamicro/javamicro_generator.h
new file mode 100644
index 0000000..a1c33b7
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_generator.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java micro code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MICRO_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_MICRO_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+// CodeGenerator implementation which generates Java micro code. If you create your
+// own protocol compiler binary and you want it to support Java output for the
+// micro runtime, you can do so by registering an instance of this CodeGenerator with
+// the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT JavaMicroGenerator : public CodeGenerator {
+ public:
+ JavaMicroGenerator();
+ ~JavaMicroGenerator();
+
+ // implements CodeGenerator ----------------------------------------
+ bool Generate(const FileDescriptor* file,
+ const string& parameter,
+ OutputDirectory* output_directory,
+ string* error) const;
+
+ private:
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaMicroGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_MICRO_GENERATOR_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_helpers.cc b/src/google/protobuf/compiler/javamicro/javamicro_helpers.cc
new file mode 100644
index 0000000..11ba71a
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_helpers.cc
@@ -0,0 +1,381 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <vector>
+
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/stubs/substitute.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+const char kThickSeparator[] =
+ "// ===================================================================\n";
+const char kThinSeparator[] =
+ "// -------------------------------------------------------------------\n";
+
+namespace {
+
+const char* kDefaultPackage = "";
+
+const string& FieldName(const FieldDescriptor* field) {
+ // Groups are hacky: The name of the field is just the lower-cased name
+ // of the group type. In Java, though, we would like to retain the original
+ // capitalization of the type name.
+ if (field->type() == FieldDescriptor::TYPE_GROUP) {
+ return field->message_type()->name();
+ } else {
+ return field->name();
+ }
+}
+
+string UnderscoresToCamelCaseImpl(const string& input, bool cap_next_letter) {
+ string result;
+ // Note: I distrust ctype.h due to locales.
+ for (int i = 0; i < input.size(); i++) {
+ if ('a' <= input[i] && input[i] <= 'z') {
+ if (cap_next_letter) {
+ result += input[i] + ('A' - 'a');
+ } else {
+ result += input[i];
+ }
+ cap_next_letter = false;
+ } else if ('A' <= input[i] && input[i] <= 'Z') {
+ if (i == 0 && !cap_next_letter) {
+ // Force first letter to lower-case unless explicitly told to
+ // capitalize it.
+ result += input[i] + ('a' - 'A');
+ } else {
+ // Capital letters after the first are left as-is.
+ result += input[i];
+ }
+ cap_next_letter = false;
+ } else if ('0' <= input[i] && input[i] <= '9') {
+ result += input[i];
+ cap_next_letter = true;
+ } else {
+ cap_next_letter = true;
+ }
+ }
+ return result;
+}
+
+} // namespace
+
+string UnderscoresToCamelCase(const FieldDescriptor* field) {
+ return UnderscoresToCamelCaseImpl(FieldName(field), false);
+}
+
+string UnderscoresToCapitalizedCamelCase(const FieldDescriptor* field) {
+ return UnderscoresToCamelCaseImpl(FieldName(field), true);
+}
+
+string UnderscoresToCamelCase(const MethodDescriptor* method) {
+ return UnderscoresToCamelCaseImpl(method->name(), false);
+}
+
+string StripProto(const string& filename) {
+ if (HasSuffixString(filename, ".protodevel")) {
+ return StripSuffixString(filename, ".protodevel");
+ } else {
+ return StripSuffixString(filename, ".proto");
+ }
+}
+
+string FileClassName(const Params& params, const FileDescriptor* file) {
+ string name;
+
+ if (params.has_java_outer_classname(file->name())) {
+ name = params.java_outer_classname(file->name());
+ } else {
+ if ((file->message_type_count() == 1)
+ || (file->enum_type_count() == 0)) {
+ // If no outer calls and only one message then
+ // use the message name as the file name
+ name = file->message_type(0)->name();
+ } else {
+ // Use the filename it self with underscores removed
+ // and a CamelCase style name.
+ string basename;
+ string::size_type last_slash = file->name().find_last_of('/');
+ if (last_slash == string::npos) {
+ basename = file->name();
+ } else {
+ basename = file->name().substr(last_slash + 1);
+ }
+ name = UnderscoresToCamelCaseImpl(StripProto(basename), true);
+ }
+ }
+
+ return name;
+}
+
+string FileJavaPackage(const Params& params, const FileDescriptor* file) {
+ if (params.has_java_package(file->name())) {
+ return params.java_package(file->name());
+ } else {
+ string result = kDefaultPackage;
+ if (!file->package().empty()) {
+ if (!result.empty()) result += '.';
+ result += file->package();
+ }
+ return result;
+ }
+}
+
+string ToJavaName(const Params& params, const string& full_name,
+ const FileDescriptor* file) {
+ string result;
+ if (params.java_multiple_files()) {
+ result = FileJavaPackage(params, file);
+ } else {
+ result = ClassName(params, file);
+ }
+ if (file->package().empty()) {
+ result += '.';
+ result += full_name;
+ } else {
+ // Strip the proto package from full_name since we've replaced it with
+ // the Java package. If there isn't an outer classname then strip it too.
+ int sizeToSkipPackageName = file->package().size();
+ int sizeToSkipOutClassName;
+ if (params.has_java_outer_classname(file->name())) {
+ sizeToSkipOutClassName = 0;
+ } else {
+ sizeToSkipOutClassName =
+ full_name.find_first_of('.', sizeToSkipPackageName + 1);
+ }
+ int sizeToSkip = sizeToSkipOutClassName > 0 ?
+ sizeToSkipOutClassName : sizeToSkipPackageName;
+ string class_name = full_name.substr(sizeToSkip + 1);
+ if (class_name == FileClassName(params, file)) {
+ // Done class_name is already present.
+ } else {
+ result += '.';
+ result += class_name;
+ }
+ }
+ return result;
+}
+
+string ClassName(const Params& params, const FileDescriptor* descriptor) {
+ string result = FileJavaPackage(params, descriptor);
+ if (!result.empty()) result += '.';
+ result += FileClassName(params, descriptor);
+ return result;
+}
+
+string ClassName(const Params& params, const EnumDescriptor* descriptor) {
+ string result;
+ const FileDescriptor* file = descriptor->file();
+ const string file_name = file->name();
+ const string full_name = descriptor->full_name();
+ int last_period = full_name.find_last_of('.');
+ int first_period = full_name.find_first_of('.');
+
+ // Remove class_name as we're using public static final int's not enums
+ string base_name = full_name.substr(0, full_name.find_last_of('.'));
+
+ if (!file->package().empty()) {
+ // Remove package name.
+ int offset = first_period;
+ if (last_period > first_period) {
+ // There was two or more periods so we need to remove this one too.
+ offset += 1;
+ }
+ base_name = base_name.substr(offset);
+ }
+
+ if (params.has_java_package(file_name)) {
+ result += params.java_package(file_name);
+ }
+ if (params.has_java_outer_classname(file_name)) {
+ result += ".";
+ result += params.java_outer_classname(file_name);
+ }
+ if (!base_name.empty()) {
+ result += ".";
+ result += base_name;
+ }
+ return result;
+}
+
+string FieldConstantName(const FieldDescriptor *field) {
+ string name = field->name() + "_FIELD_NUMBER";
+ UpperString(&name);
+ return name;
+}
+
+JavaType GetJavaType(FieldDescriptor::Type field_type) {
+ switch (field_type) {
+ case FieldDescriptor::TYPE_INT32:
+ case FieldDescriptor::TYPE_UINT32:
+ case FieldDescriptor::TYPE_SINT32:
+ case FieldDescriptor::TYPE_FIXED32:
+ case FieldDescriptor::TYPE_SFIXED32:
+ return JAVATYPE_INT;
+
+ case FieldDescriptor::TYPE_INT64:
+ case FieldDescriptor::TYPE_UINT64:
+ case FieldDescriptor::TYPE_SINT64:
+ case FieldDescriptor::TYPE_FIXED64:
+ case FieldDescriptor::TYPE_SFIXED64:
+ return JAVATYPE_LONG;
+
+ case FieldDescriptor::TYPE_FLOAT:
+ return JAVATYPE_FLOAT;
+
+ case FieldDescriptor::TYPE_DOUBLE:
+ return JAVATYPE_DOUBLE;
+
+ case FieldDescriptor::TYPE_BOOL:
+ return JAVATYPE_BOOLEAN;
+
+ case FieldDescriptor::TYPE_STRING:
+ return JAVATYPE_STRING;
+
+ case FieldDescriptor::TYPE_BYTES:
+ return JAVATYPE_BYTES;
+
+ case FieldDescriptor::TYPE_ENUM:
+ return JAVATYPE_ENUM;
+
+ case FieldDescriptor::TYPE_GROUP:
+ case FieldDescriptor::TYPE_MESSAGE:
+ return JAVATYPE_MESSAGE;
+
+ // No default because we want the compiler to complain if any new
+ // types are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return JAVATYPE_INT;
+}
+
+const char* BoxedPrimitiveTypeName(JavaType type) {
+ switch (type) {
+ case JAVATYPE_INT : return "java.lang.Integer";
+ case JAVATYPE_LONG : return "java.lang.Long";
+ case JAVATYPE_FLOAT : return "java.lang.Float";
+ case JAVATYPE_DOUBLE : return "java.lang.Double";
+ case JAVATYPE_BOOLEAN: return "java.lang.Boolean";
+ case JAVATYPE_STRING : return "java.lang.String";
+ case JAVATYPE_BYTES : return "com.google.protobuf.micro.ByteStringMicro";
+ case JAVATYPE_ENUM : return "java.lang.Integer";
+ case JAVATYPE_MESSAGE: return NULL;
+
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return NULL;
+}
+
+bool AllAscii(const string& text) {
+ for (int i = 0; i < text.size(); i++) {
+ if ((text[i] & 0x80) != 0) {
+ return false;
+ }
+ }
+ return true;
+}
+
+string DefaultValue(const Params& params, const FieldDescriptor* field) {
+ // Switch on cpp_type since we need to know which default_value_* method
+ // of FieldDescriptor to call.
+ switch (field->cpp_type()) {
+ case FieldDescriptor::CPPTYPE_INT32:
+ return SimpleItoa(field->default_value_int32());
+ case FieldDescriptor::CPPTYPE_UINT32:
+ // Need to print as a signed int since Java has no unsigned.
+ return SimpleItoa(static_cast<int32>(field->default_value_uint32()));
+ case FieldDescriptor::CPPTYPE_INT64:
+ return SimpleItoa(field->default_value_int64()) + "L";
+ case FieldDescriptor::CPPTYPE_UINT64:
+ return SimpleItoa(static_cast<int64>(field->default_value_uint64())) +
+ "L";
+ case FieldDescriptor::CPPTYPE_DOUBLE:
+ return SimpleDtoa(field->default_value_double()) + "D";
+ case FieldDescriptor::CPPTYPE_FLOAT:
+ return SimpleFtoa(field->default_value_float()) + "F";
+ case FieldDescriptor::CPPTYPE_BOOL:
+ return field->default_value_bool() ? "true" : "false";
+ case FieldDescriptor::CPPTYPE_STRING:
+ if (field->type() == FieldDescriptor::TYPE_BYTES) {
+ if (field->has_default_value()) {
+ // See comments in Internal.java for gory details.
+ return strings::Substitute(
+ "com.google.protobuf.micro.ByteStringMicro.copyFromUtf8(\"$0\")",
+ CEscape(field->default_value_string()));
+ } else {
+ return "com.google.protobuf.micro.ByteStringMicro.EMPTY";
+ }
+ } else {
+ if (AllAscii(field->default_value_string())) {
+ // All chars are ASCII. In this case CEscape() works fine.
+ return "\"" + CEscape(field->default_value_string()) + "\"";
+ } else {
+ // See comments in Internal.java for gory details.
+ // BUG: Internal NOT SUPPORTED need to fix!!
+ return strings::Substitute(
+ "com.google.protobuf.micro.Internal.stringDefaultValue(\"$0\")",
+ CEscape(field->default_value_string()));
+ }
+ }
+
+ case FieldDescriptor::CPPTYPE_ENUM:
+ return ClassName(params, field->enum_type()) + "." +
+ field->default_value_enum()->name();
+
+ case FieldDescriptor::CPPTYPE_MESSAGE:
+ return ClassName(params, field->message_type()) + ".getDefaultInstance()";
+
+ // No default because we want the compiler to complain if any new
+ // types are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return "";
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_helpers.h b/src/google/protobuf/compiler/javamicro/javamicro_helpers.h
new file mode 100644
index 0000000..eeddbf9
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_helpers.h
@@ -0,0 +1,128 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__
+
+#include <string>
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+// Commonly-used separator comments. Thick is a line of '=', thin is a line
+// of '-'.
+extern const char kThickSeparator[];
+extern const char kThinSeparator[];
+
+// Converts the field's name to camel-case, e.g. "foo_bar_baz" becomes
+// "fooBarBaz" or "FooBarBaz", respectively.
+string UnderscoresToCamelCase(const FieldDescriptor* field);
+string UnderscoresToCapitalizedCamelCase(const FieldDescriptor* field);
+
+// Similar, but for method names. (Typically, this merely has the effect
+// of lower-casing the first letter of the name.)
+string UnderscoresToCamelCase(const MethodDescriptor* method);
+
+// Strips ".proto" or ".protodevel" from the end of a filename.
+string StripProto(const string& filename);
+
+// Gets the unqualified class name for the file. Each .proto file becomes a
+// single Java class, with all its contents nested in that class.
+string FileClassName(const Params& params, const FileDescriptor* file);
+
+// Returns the file's Java package name.
+string FileJavaPackage(const Params& params, const FileDescriptor* file);
+
+// Converts the given fully-qualified name in the proto namespace to its
+// fully-qualified name in the Java namespace, given that it is in the given
+// file.
+string ToJavaName(const Params& params, const string& full_name,
+ const FileDescriptor* file);
+
+// These return the fully-qualified class name corresponding to the given
+// descriptor.
+inline string ClassName(const Params& params, const Descriptor* descriptor) {
+ return ToJavaName(params, descriptor->full_name(), descriptor->file());
+}
+string ClassName(const Params& params, const EnumDescriptor* descriptor);
+inline string ClassName(const Params& params,
+ const ServiceDescriptor* descriptor) {
+ return ToJavaName(params, descriptor->full_name(), descriptor->file());
+}
+inline string ExtensionIdentifierName(const Params& params,
+ const FieldDescriptor* descriptor) {
+ return ToJavaName(params, descriptor->full_name(), descriptor->file());
+}
+string ClassName(const Params& params, const FileDescriptor* descriptor);
+
+// Get the unqualified name that should be used for a field's field
+// number constant.
+string FieldConstantName(const FieldDescriptor *field);
+
+enum JavaType {
+ JAVATYPE_INT,
+ JAVATYPE_LONG,
+ JAVATYPE_FLOAT,
+ JAVATYPE_DOUBLE,
+ JAVATYPE_BOOLEAN,
+ JAVATYPE_STRING,
+ JAVATYPE_BYTES,
+ JAVATYPE_ENUM,
+ JAVATYPE_MESSAGE
+};
+
+JavaType GetJavaType(FieldDescriptor::Type field_type);
+
+inline JavaType GetJavaType(const FieldDescriptor* field) {
+ return GetJavaType(field->type());
+}
+
+// Get the fully-qualified class name for a boxed primitive type, e.g.
+// "java.lang.Integer" for JAVATYPE_INT. Returns NULL for enum and message
+// types.
+const char* BoxedPrimitiveTypeName(JavaType type);
+
+string DefaultValue(const Params& params, const FieldDescriptor* field);
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_HELPERS_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_message.cc b/src/google/protobuf/compiler/javamicro/javamicro_message.cc
new file mode 100644
index 0000000..7fc6c3d
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_message.cc
@@ -0,0 +1,474 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <algorithm>
+#include <google/protobuf/stubs/hash.h>
+#include <google/protobuf/compiler/javamicro/javamicro_message.h>
+#include <google/protobuf/compiler/javamicro/javamicro_enum.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format.h>
+#include <google/protobuf/descriptor.pb.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+using internal::WireFormat;
+using internal::WireFormatLite;
+
+namespace {
+
+void PrintFieldComment(io::Printer* printer, const FieldDescriptor* field) {
+ // Print the field's proto-syntax definition as a comment. We don't want to
+ // print group bodies so we cut off after the first line.
+ string def = field->DebugString();
+ printer->Print("// $def$\n",
+ "def", def.substr(0, def.find_first_of('\n')));
+}
+
+struct FieldOrderingByNumber {
+ inline bool operator()(const FieldDescriptor* a,
+ const FieldDescriptor* b) const {
+ return a->number() < b->number();
+ }
+};
+
+// Sort the fields of the given Descriptor by number into a new[]'d array
+// and return it.
+const FieldDescriptor** SortFieldsByNumber(const Descriptor* descriptor) {
+ const FieldDescriptor** fields =
+ new const FieldDescriptor*[descriptor->field_count()];
+ for (int i = 0; i < descriptor->field_count(); i++) {
+ fields[i] = descriptor->field(i);
+ }
+ sort(fields, fields + descriptor->field_count(),
+ FieldOrderingByNumber());
+ return fields;
+}
+
+// Get an identifier that uniquely identifies this type within the file.
+// This is used to declare static variables related to this type at the
+// outermost file scope.
+string UniqueFileScopeIdentifier(const Descriptor* descriptor) {
+ return "static_" + StringReplace(descriptor->full_name(), ".", "_", true);
+}
+
+// Returns true if the message type has any required fields. If it doesn't,
+// we can optimize out calls to its isInitialized() method.
+//
+// already_seen is used to avoid checking the same type multiple times
+// (and also to protect against recursion).
+static bool HasRequiredFields(
+ const Descriptor* type,
+ hash_set<const Descriptor*>* already_seen) {
+ if (already_seen->count(type) > 0) {
+ // The type is already in cache. This means that either:
+ // a. The type has no required fields.
+ // b. We are in the midst of checking if the type has required fields,
+ // somewhere up the stack. In this case, we know that if the type
+ // has any required fields, they'll be found when we return to it,
+ // and the whole call to HasRequiredFields() will return true.
+ // Therefore, we don't have to check if this type has required fields
+ // here.
+ return false;
+ }
+ already_seen->insert(type);
+
+ // If the type has extensions, an extension with message type could contain
+ // required fields, so we have to be conservative and assume such an
+ // extension exists.
+ if (type->extension_range_count() > 0) return true;
+
+ for (int i = 0; i < type->field_count(); i++) {
+ const FieldDescriptor* field = type->field(i);
+ if (field->is_required()) {
+ return true;
+ }
+ if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+ if (HasRequiredFields(field->message_type(), already_seen)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+static bool HasRequiredFields(const Descriptor* type) {
+ hash_set<const Descriptor*> already_seen;
+ return HasRequiredFields(type, &already_seen);
+}
+
+} // namespace
+
+// ===================================================================
+
+MessageGenerator::MessageGenerator(const Descriptor* descriptor, const Params& params)
+ : params_(params),
+ descriptor_(descriptor),
+ field_generators_(descriptor, params) {
+}
+
+MessageGenerator::~MessageGenerator() {}
+
+void MessageGenerator::GenerateStaticVariables(io::Printer* printer) {
+ // Generate static members for all nested types.
+ for (int i = 0; i < descriptor_->nested_type_count(); i++) {
+ // TODO(kenton): Reuse MessageGenerator objects?
+ MessageGenerator(descriptor_->nested_type(i), params_)
+ .GenerateStaticVariables(printer);
+ }
+}
+
+void MessageGenerator::GenerateStaticVariableInitializers(
+ io::Printer* printer) {
+ // Generate static member initializers for all nested types.
+ for (int i = 0; i < descriptor_->nested_type_count(); i++) {
+ // TODO(kenton): Reuse MessageGenerator objects?
+ MessageGenerator(descriptor_->nested_type(i), params_)
+ .GenerateStaticVariableInitializers(printer);
+ }
+
+ if (descriptor_->extension_count() != 0) {
+ GOOGLE_LOG(FATAL) << "Extensions not supported in MICRO_RUNTIME\n";
+ }
+}
+
+void MessageGenerator::Generate(io::Printer* printer) {
+ bool is_own_file =
+ params_.java_multiple_files() || ((descriptor_->containing_type() == NULL)
+ && !params_.has_java_outer_classname(descriptor_->file()->name()));
+
+#if 0
+ GOOGLE_LOG(INFO) << "is_own_file=" << is_own_file;
+ GOOGLE_LOG(INFO) << "containing_type()=" << ((descriptor_->containing_type() == NULL) ? "NULL" : "not null");
+ GOOGLE_LOG(INFO) << "java_multiple_files()=" << params_.java_multiple_files();
+ GOOGLE_LOG(INFO) << "has_java_outer_classname()=" << params_.has_java_outer_classname(file_->name());
+#endif
+
+ if ((descriptor_->extension_count() != 0)
+ || (descriptor_->extension_range_count() != 0)) {
+ GOOGLE_LOG(FATAL) << "Extensions not supported in MICRO_RUNTIME\n";
+ }
+
+ printer->Print(
+ "public $modifiers$ final class $classname$ extends\n"
+ " com.google.protobuf.micro.MessageMicro {\n",
+ "modifiers", is_own_file ? "" : "static",
+ "classname", descriptor_->name());
+ printer->Indent();
+ printer->Print(
+ "public $classname$() {}\n"
+ "\n",
+ "classname", descriptor_->name());
+
+ // Nested types and extensions
+ for (int i = 0; i < descriptor_->enum_type_count(); i++) {
+ EnumGenerator(descriptor_->enum_type(i), params_).Generate(printer);
+ }
+
+ for (int i = 0; i < descriptor_->nested_type_count(); i++) {
+ MessageGenerator(descriptor_->nested_type(i), params_).Generate(printer);
+ }
+
+ // Fields
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ PrintFieldComment(printer, descriptor_->field(i));
+ printer->Print("public static final int $constant_name$ = $number$;\n",
+ "constant_name", FieldConstantName(descriptor_->field(i)),
+ "number", SimpleItoa(descriptor_->field(i)->number()));
+ field_generators_.get(descriptor_->field(i)).GenerateMembers(printer);
+ printer->Print("\n");
+ }
+
+ GenerateClear(printer);
+ GenerateIsInitialized(printer);
+ GenerateMessageSerializationMethods(printer);
+ GenerateMergeFromMethods(printer);
+ GenerateParseFromMethods(printer);
+
+ printer->Outdent();
+ printer->Print("}\n\n");
+}
+
+// ===================================================================
+
+void MessageGenerator::
+GenerateMessageSerializationMethods(io::Printer* printer) {
+ scoped_array<const FieldDescriptor*> sorted_fields(
+ SortFieldsByNumber(descriptor_));
+
+ if (descriptor_->extension_range_count() != 0) {
+ GOOGLE_LOG(FATAL) << "Extensions not supported in MICRO_RUNTIME\n";
+ }
+
+ printer->Print(
+ "public void writeTo(com.google.protobuf.micro.CodedOutputStreamMicro output)\n"
+ " throws java.io.IOException {\n");
+ printer->Indent();
+
+ // Output the fields in sorted order
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ GenerateSerializeOneField(printer, sorted_fields[i]);
+ }
+
+ printer->Outdent();
+ printer->Print(
+ "}\n"
+ "\n"
+ "private int cachedSize = -1;\n"
+ "public int getCachedSize() {\n"
+ " if (cachedSize < 0) {\n"
+ " // getSerializedSize sets cachedSize\n"
+ " getSerializedSize();\n"
+ " }\n"
+ " return cachedSize;\n"
+ "}\n"
+ "\n"
+ "public int getSerializedSize() {\n"
+ " int size = 0;\n");
+ printer->Indent();
+
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ field_generators_.get(sorted_fields[i]).GenerateSerializedSizeCode(printer);
+ }
+
+ printer->Outdent();
+ printer->Print(
+ " cachedSize = size;\n"
+ " return size;\n"
+ "}\n"
+ "\n");
+}
+
+void MessageGenerator::GenerateMergeFromMethods(io::Printer* printer) {
+ scoped_array<const FieldDescriptor*> sorted_fields(
+ SortFieldsByNumber(descriptor_));
+
+ if (params_.java_use_vector()) {
+ printer->Print(
+ "public com.google.protobuf.micro.MessageMicro mergeFrom(\n"
+ " com.google.protobuf.micro.CodedInputStreamMicro input)\n"
+ " throws java.io.IOException {\n",
+ "classname", descriptor_->name());
+ } else {
+ printer->Print(
+ "public $classname$ mergeFrom(\n"
+ " com.google.protobuf.micro.CodedInputStreamMicro input)\n"
+ " throws java.io.IOException {\n",
+ "classname", descriptor_->name());
+ }
+ printer->Indent();
+
+ printer->Print(
+ "while (true) {\n");
+ printer->Indent();
+
+ printer->Print(
+ "int tag = input.readTag();\n"
+ "switch (tag) {\n");
+ printer->Indent();
+
+ printer->Print(
+ "case 0:\n" // zero signals EOF / limit reached
+ " return this;\n"
+ "default: {\n"
+ " if (!parseUnknownField(input, tag)) {\n"
+ " return this;\n" // it's an endgroup tag
+ " }\n"
+ " break;\n"
+ "}\n");
+
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = sorted_fields[i];
+ uint32 tag = WireFormatLite::MakeTag(field->number(),
+ WireFormat::WireTypeForField(field));
+
+ printer->Print(
+ "case $tag$: {\n",
+ "tag", SimpleItoa(tag));
+ printer->Indent();
+
+ field_generators_.get(field).GenerateParsingCode(printer);
+
+ printer->Outdent();
+ printer->Print(
+ " break;\n"
+ "}\n");
+ }
+
+ printer->Outdent();
+ printer->Outdent();
+ printer->Outdent();
+ printer->Print(
+ " }\n" // switch (tag)
+ " }\n" // while (true)
+ "}\n"
+ "\n");
+}
+
+void MessageGenerator::
+GenerateParseFromMethods(io::Printer* printer) {
+ bool is_own_file =
+ descriptor_->containing_type() == NULL;
+
+ // Note: These are separate from GenerateMessageSerializationMethods()
+ // because they need to be generated even for messages that are optimized
+ // for code size.
+ printer->Print(
+ "public $static$ $classname$ parseFrom(byte[] data)\n"
+ " throws com.google.protobuf.micro.InvalidProtocolBufferMicroException {\n"
+ " return ($classname$) (new $classname$().mergeFrom(data));\n"
+ "}\n"
+ "\n"
+ "public $static$ $classname$ parseFrom(\n"
+ " com.google.protobuf.micro.CodedInputStreamMicro input)\n"
+ " throws java.io.IOException {\n"
+ " return ($classname$) (new $classname$().mergeFrom(input));\n"
+ "}\n"
+ "\n",
+ "static", (is_own_file ? "static" : ""),
+ "classname", descriptor_->name());
+}
+
+void MessageGenerator::GenerateSerializeOneField(
+ io::Printer* printer, const FieldDescriptor* field) {
+ field_generators_.get(field).GenerateSerializationCode(printer);
+}
+
+void MessageGenerator::GenerateClear(io::Printer* printer) {
+ printer->Print(
+ "public final $classname$ clear() {\n",
+ "classname", descriptor_->name());
+ printer->Indent();
+
+ // Call clear for all of the fields.
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = descriptor_->field(i);
+
+ printer->Print(
+ "clear$name$();\n",
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ }
+
+ printer->Outdent();
+ printer->Print(
+ " cachedSize = -1;\n"
+ " return this;\n"
+ "}\n"
+ "\n");
+}
+
+
+void MessageGenerator::GenerateIsInitialized(io::Printer* printer) {
+ printer->Print(
+ "public final boolean isInitialized() {\n");
+ printer->Indent();
+
+ // Check that all required fields in this message are set.
+ // TODO(kenton): We can optimize this when we switch to putting all the
+ // "has" fields into a single bitfield.
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = descriptor_->field(i);
+
+ if (field->is_required()) {
+ printer->Print(
+ "if (!has$name$) return false;\n",
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ }
+ }
+
+ // Now check that all embedded messages are initialized.
+ for (int i = 0; i < descriptor_->field_count(); i++) {
+ const FieldDescriptor* field = descriptor_->field(i);
+ if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+ HasRequiredFields(field->message_type())) {
+ switch (field->label()) {
+ case FieldDescriptor::LABEL_REQUIRED:
+ printer->Print(
+ "if (!get$name$().isInitialized()) return false;\n",
+ "type", ClassName(params_, field->message_type()),
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ break;
+ case FieldDescriptor::LABEL_OPTIONAL:
+ printer->Print(
+ "if (has$name$()) {\n"
+ " if (!get$name$().isInitialized()) return false;\n"
+ "}\n",
+ "type", ClassName(params_, field->message_type()),
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ break;
+ case FieldDescriptor::LABEL_REPEATED:
+ if (params_.java_use_vector()) {
+ printer->Print(
+ "for (int i = 0; i < get$name$List().size(); i++) {\n"
+ " if (get$name$(i).isInitialized()) return false;\n"
+ "}\n",
+ "type", ClassName(params_, field->message_type()),
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ } else {
+ printer->Print(
+ "for ($type$ element : get$name$List()) {\n"
+ " if (!element.isInitialized()) return false;\n"
+ "}\n",
+ "type", ClassName(params_, field->message_type()),
+ "name", UnderscoresToCapitalizedCamelCase(field));
+ }
+ break;
+ }
+ }
+ }
+
+ if (descriptor_->extension_range_count() > 0) {
+ printer->Print(
+ "if (!extensionsAreInitialized()) return false;\n");
+ }
+
+ printer->Outdent();
+ printer->Print(
+ " return true;\n"
+ "}\n"
+ "\n");
+}
+
+// ===================================================================
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_message.h b/src/google/protobuf/compiler/javamicro/javamicro_message.h
new file mode 100644
index 0000000..f44c7a7
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_message.h
@@ -0,0 +1,93 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/javamicro/javamicro_params.h>
+#include <google/protobuf/compiler/javamicro/javamicro_field.h>
+
+namespace google {
+namespace protobuf {
+ namespace io {
+ class Printer; // printer.h
+ }
+}
+
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class MessageGenerator {
+ public:
+ explicit MessageGenerator(const Descriptor* descriptor, const Params& params);
+ ~MessageGenerator();
+
+ // All static variables have to be declared at the top-level of the file
+ // so that we can control initialization order, which is important for
+ // DescriptorProto bootstrapping to work.
+ void GenerateStaticVariables(io::Printer* printer);
+
+ // Output code which initializes the static variables generated by
+ // GenerateStaticVariables().
+ void GenerateStaticVariableInitializers(io::Printer* printer);
+
+ // Generate the class itself.
+ void Generate(io::Printer* printer);
+
+ private:
+ void GenerateMessageSerializationMethods(io::Printer* printer);
+ void GenerateMergeFromMethods(io::Printer* printer);
+ void GenerateParseFromMethods(io::Printer* printer);
+ void GenerateSerializeOneField(io::Printer* printer,
+ const FieldDescriptor* field);
+
+ void GenerateClear(io::Printer* printer);
+ void GenerateIsInitialized(io::Printer* printer);
+
+ const Params& params_;
+ const Descriptor* descriptor_;
+ FieldGeneratorMap field_generators_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_message_field.cc b/src/google/protobuf/compiler/javamicro/javamicro_message_field.cc
new file mode 100644
index 0000000..103c302
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_message_field.cc
@@ -0,0 +1,302 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <map>
+#include <string>
+
+#include <google/protobuf/compiler/javamicro/javamicro_message_field.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/wire_format.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+namespace {
+
+// TODO(kenton): Factor out a "SetCommonFieldVariables()" to get rid of
+// repeat code between this and the other field types.
+void SetMessageVariables(const Params& params,
+ const FieldDescriptor* descriptor, map<string, string>* variables) {
+ (*variables)["name"] =
+ UnderscoresToCamelCase(descriptor);
+ (*variables)["capitalized_name"] =
+ UnderscoresToCapitalizedCamelCase(descriptor);
+ (*variables)["number"] = SimpleItoa(descriptor->number());
+ (*variables)["type"] = ClassName(params, descriptor->message_type());
+ (*variables)["group_or_message"] =
+ (descriptor->type() == FieldDescriptor::TYPE_GROUP) ?
+ "Group" : "Message";
+ (*variables)["message_name"] = descriptor->containing_type()->name();
+ //(*variables)["message_type"] = descriptor->message_type()->name();
+}
+
+} // namespace
+
+// ===================================================================
+
+MessageFieldGenerator::
+MessageFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetMessageVariables(params, descriptor, &variables_);
+}
+
+MessageFieldGenerator::~MessageFieldGenerator() {}
+
+void MessageFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ printer->Print(variables_,
+ "private boolean has$capitalized_name$;\n"
+// "private $type$ $name$_ = null;\n"
+// "public boolean has$capitalized_name$() { return has$capitalized_name$; }\n"
+// "public $type$ get$capitalized_name$() { return $name$_; }\n"
+ "private $type$ $name$_ = null;\n"
+ "public boolean has$capitalized_name$() { return has$capitalized_name$; }\n"
+ "public $type$ get$capitalized_name$() { return $name$_; }\n"
+ "public $message_name$ set$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " has$capitalized_name$ = true;\n"
+ " $name$_ = value;\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " has$capitalized_name$ = false;\n"
+ " $name$_ = null;\n"
+ " return this;\n"
+ "}\n");
+}
+
+void MessageFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (other.has$capitalized_name$()) {\n"
+ " merge$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
+}
+
+void MessageFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "$type$ value = new $type$();\n");
+
+ if (descriptor_->type() == FieldDescriptor::TYPE_GROUP) {
+ printer->Print(variables_,
+ "input.readGroup(value, $number$);\n");
+ } else {
+ printer->Print(variables_,
+ "input.readMessage(value);\n");
+ }
+
+ printer->Print(variables_,
+ "set$capitalized_name$(value);\n");
+}
+
+void MessageFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " output.write$group_or_message$($number$, get$capitalized_name$());\n"
+ "}\n");
+}
+
+void MessageFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .compute$group_or_message$Size($number$, get$capitalized_name$());\n"
+ "}\n");
+}
+
+string MessageFieldGenerator::GetBoxedType() const {
+ return ClassName(params_, descriptor_->message_type());
+}
+
+// ===================================================================
+
+RepeatedMessageFieldGenerator::
+RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetMessageVariables(params, descriptor, &variables_);
+}
+
+RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {}
+
+void RepeatedMessageFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "private java.util.Vector $name$_ = new java.util.Vector();\n"
+ "public java.util.Vector get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public $type$ get$capitalized_name$(int index) {\n"
+ " return ($type$) $name$_.elementAt(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $name$_.setElementAt(value, index);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $name$_.addElement(value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_.removeAllElements();\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "private java.util.List<$type$> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
+ "public java.util.List<$type$> get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public $type$ get$capitalized_name$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, $type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " $name$_.set(index, value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$($type$ value) {\n"
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = new java.util.ArrayList<$type$>();\n"
+ " }\n"
+ " $name$_.add(value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_ = java.util.Collections.emptyList();\n"
+ " return this;\n"
+ "}\n");
+ }
+}
+
+void RepeatedMessageFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "if (other.$name$_.size() != 0) {\n"
+ " for (int i = 0; i < other.$name$_.size(); i++) {\n"
+ " result.$name$_.addElement(other.$name$_.elementAt(i));\n"
+ " }\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if (result.$name$_.isEmpty()) {\n"
+ " result.$name$_ = new java.util.ArrayList<$type$>();\n"
+ " }\n"
+ " result.$name$_.addAll(other.$name$_);\n"
+ "}\n");
+ }
+}
+
+void RepeatedMessageFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "$type$ value = new $type$();\n");
+
+ if (descriptor_->type() == FieldDescriptor::TYPE_GROUP) {
+ printer->Print(variables_,
+ "input.readGroup(value, $number$);\n");
+ } else {
+ printer->Print(variables_,
+ "input.readMessage(value);\n");
+ }
+
+ printer->Print(variables_,
+ "add$capitalized_name$(value);\n");
+}
+
+void RepeatedMessageFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.write$group_or_message$($number$, get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " output.write$group_or_message$($number$, element);\n"
+ "}\n");
+ }
+}
+
+void RepeatedMessageFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .compute$group_or_message$Size($number$, get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .compute$group_or_message$Size($number$, element);\n"
+ "}\n");
+ }
+}
+
+string RepeatedMessageFieldGenerator::GetBoxedType() const {
+ return ClassName(params_, descriptor_->message_type());
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_message_field.h b/src/google/protobuf/compiler/javamicro/javamicro_message_field.h
new file mode 100644
index 0000000..a32aa4e
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_message_field.h
@@ -0,0 +1,95 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_FIELD_H__
+
+#include <map>
+#include <string>
+#include <google/protobuf/compiler/javamicro/javamicro_field.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class MessageFieldGenerator : public FieldGenerator {
+ public:
+ explicit MessageFieldGenerator(const FieldDescriptor* descriptor, const Params& params);
+ ~MessageFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFieldGenerator);
+};
+
+class RepeatedMessageFieldGenerator : public FieldGenerator {
+ public:
+ explicit RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor,
+ const Params& params);
+ ~RepeatedMessageFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedMessageFieldGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_FIELD_H__
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_params.h b/src/google/protobuf/compiler/javamicro/javamicro_params.h
new file mode 100644
index 0000000..a4a72b7
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_params.h
@@ -0,0 +1,143 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2010 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: wink@google.com (Wink Saville)
+
+#ifndef PROTOBUF_COMPILER_JAVAMICRO_JAVAMICRO_PARAMS_H_
+#define PROTOBUF_COMPILER_JAVAMICRO_JAVAMICRO_PARAMS_H_
+
+#include <map>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+enum eOptimization { JAVAMICRO_OPT_SPEED, JAVAMICRO_OPT_SPACE, JAVAMICRO_OPT_DEFAULT = JAVAMICRO_OPT_SPACE };
+
+// Parameters for used by the generators
+class Params {
+ public:
+ typedef map<string, string> NameMap;
+ private:
+ string empty_;
+ string base_name_;
+ eOptimization optimization_;
+ bool java_multiple_files_;
+ bool java_use_vector_;
+ NameMap java_packages_;
+ NameMap java_outer_classnames_;
+
+ public:
+ Params(const string & base_name) :
+ empty_(""),
+ base_name_(base_name),
+ optimization_(JAVAMICRO_OPT_DEFAULT),
+ java_multiple_files_(false),
+ java_use_vector_(false) {
+ }
+
+ const string& base_name() const {
+ return base_name_;
+ }
+
+ bool has_java_package(const string& file_name) const {
+ return java_packages_.find(file_name)
+ != java_packages_.end();
+ }
+ void set_java_package(const string& file_name,
+ const string& java_package) {
+ java_packages_[file_name] = java_package;
+ }
+ const string& java_package(const string& file_name) const {
+ NameMap::const_iterator itr;
+
+ itr = java_packages_.find(file_name);
+ if (itr == java_packages_.end()) {
+ return empty_;
+ } else {
+ return itr->second;
+ }
+ }
+ const NameMap& java_packages() {
+ return java_packages_;
+ }
+
+ bool has_java_outer_classname(const string& file_name) const {
+ return java_outer_classnames_.find(file_name)
+ != java_outer_classnames_.end();
+ }
+ void set_java_outer_classname(const string& file_name,
+ const string& java_outer_classname) {
+ java_outer_classnames_[file_name] = java_outer_classname;
+ }
+ const string& java_outer_classname(const string& file_name) const {
+ NameMap::const_iterator itr;
+
+ itr = java_outer_classnames_.find(file_name);
+ if (itr == java_outer_classnames_.end()) {
+ return empty_;
+ } else {
+ return itr->second;
+ }
+ }
+ const NameMap& java_outer_classnames() {
+ return java_outer_classnames_;
+ }
+
+ void set_optimization(eOptimization optimization) {
+ optimization_ = optimization;
+ }
+ eOptimization optimization() const {
+ return optimization_;
+ }
+
+ void set_java_multiple_files(bool value) {
+ java_multiple_files_ = value;
+ }
+ bool java_multiple_files() const {
+ return java_multiple_files_;
+ }
+
+ void set_java_use_vector(bool value) {
+ java_use_vector_ = value;
+ }
+ bool java_use_vector() const {
+ return java_use_vector_;
+ }
+
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
+#endif // PROTOBUF_COMPILER_JAVAMICRO_JAVAMICRO_PARAMS_H_
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.cc b/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.cc
new file mode 100644
index 0000000..d6daa44
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.cc
@@ -0,0 +1,660 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#include <map>
+#include <string>
+
+#include <google/protobuf/compiler/javamicro/javamicro_primitive_field.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/javamicro/javamicro_helpers.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/wire_format.h>
+#include <google/protobuf/stubs/strutil.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+using internal::WireFormat;
+using internal::WireFormatLite;
+
+namespace {
+
+const char* PrimitiveTypeName(JavaType type) {
+ switch (type) {
+ case JAVATYPE_INT : return "int";
+ case JAVATYPE_LONG : return "long";
+ case JAVATYPE_FLOAT : return "float";
+ case JAVATYPE_DOUBLE : return "double";
+ case JAVATYPE_BOOLEAN: return "boolean";
+ case JAVATYPE_STRING : return "java.lang.String";
+ case JAVATYPE_BYTES : return "com.google.protobuf.micro.ByteStringMicro";
+ case JAVATYPE_ENUM : return NULL;
+ case JAVATYPE_MESSAGE: return NULL;
+
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return NULL;
+}
+
+bool IsReferenceType(JavaType type) {
+ switch (type) {
+ case JAVATYPE_INT : return false;
+ case JAVATYPE_LONG : return false;
+ case JAVATYPE_FLOAT : return false;
+ case JAVATYPE_DOUBLE : return false;
+ case JAVATYPE_BOOLEAN: return false;
+ case JAVATYPE_STRING : return true;
+ case JAVATYPE_BYTES : return true;
+ case JAVATYPE_ENUM : return false;
+ case JAVATYPE_MESSAGE: return true;
+
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return false;
+}
+
+const char* GetCapitalizedType(const FieldDescriptor* field) {
+ switch (field->type()) {
+ case FieldDescriptor::TYPE_INT32 : return "Int32" ;
+ case FieldDescriptor::TYPE_UINT32 : return "UInt32" ;
+ case FieldDescriptor::TYPE_SINT32 : return "SInt32" ;
+ case FieldDescriptor::TYPE_FIXED32 : return "Fixed32" ;
+ case FieldDescriptor::TYPE_SFIXED32: return "SFixed32";
+ case FieldDescriptor::TYPE_INT64 : return "Int64" ;
+ case FieldDescriptor::TYPE_UINT64 : return "UInt64" ;
+ case FieldDescriptor::TYPE_SINT64 : return "SInt64" ;
+ case FieldDescriptor::TYPE_FIXED64 : return "Fixed64" ;
+ case FieldDescriptor::TYPE_SFIXED64: return "SFixed64";
+ case FieldDescriptor::TYPE_FLOAT : return "Float" ;
+ case FieldDescriptor::TYPE_DOUBLE : return "Double" ;
+ case FieldDescriptor::TYPE_BOOL : return "Bool" ;
+ case FieldDescriptor::TYPE_STRING : return "String" ;
+ case FieldDescriptor::TYPE_BYTES : return "Bytes" ;
+ case FieldDescriptor::TYPE_ENUM : return "Enum" ;
+ case FieldDescriptor::TYPE_GROUP : return "Group" ;
+ case FieldDescriptor::TYPE_MESSAGE : return "Message" ;
+
+ // No default because we want the compiler to complain if any new
+ // types are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return NULL;
+}
+
+// For encodings with fixed sizes, returns that size in bytes. Otherwise
+// returns -1.
+int FixedSize(FieldDescriptor::Type type) {
+ switch (type) {
+ case FieldDescriptor::TYPE_INT32 : return -1;
+ case FieldDescriptor::TYPE_INT64 : return -1;
+ case FieldDescriptor::TYPE_UINT32 : return -1;
+ case FieldDescriptor::TYPE_UINT64 : return -1;
+ case FieldDescriptor::TYPE_SINT32 : return -1;
+ case FieldDescriptor::TYPE_SINT64 : return -1;
+ case FieldDescriptor::TYPE_FIXED32 : return WireFormatLite::kFixed32Size;
+ case FieldDescriptor::TYPE_FIXED64 : return WireFormatLite::kFixed64Size;
+ case FieldDescriptor::TYPE_SFIXED32: return WireFormatLite::kSFixed32Size;
+ case FieldDescriptor::TYPE_SFIXED64: return WireFormatLite::kSFixed64Size;
+ case FieldDescriptor::TYPE_FLOAT : return WireFormatLite::kFloatSize;
+ case FieldDescriptor::TYPE_DOUBLE : return WireFormatLite::kDoubleSize;
+
+ case FieldDescriptor::TYPE_BOOL : return WireFormatLite::kBoolSize;
+ case FieldDescriptor::TYPE_ENUM : return -1;
+
+ case FieldDescriptor::TYPE_STRING : return -1;
+ case FieldDescriptor::TYPE_BYTES : return -1;
+ case FieldDescriptor::TYPE_GROUP : return -1;
+ case FieldDescriptor::TYPE_MESSAGE : return -1;
+
+ // No default because we want the compiler to complain if any new
+ // types are added.
+ }
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return -1;
+}
+
+// Return true if the type is a that has variable length
+// for instance String's.
+bool IsVariableLenType(JavaType type) {
+ switch (type) {
+ case JAVATYPE_INT : return false;
+ case JAVATYPE_LONG : return false;
+ case JAVATYPE_FLOAT : return false;
+ case JAVATYPE_DOUBLE : return false;
+ case JAVATYPE_BOOLEAN: return false;
+ case JAVATYPE_STRING : return true;
+ case JAVATYPE_BYTES : return true;
+ case JAVATYPE_ENUM : return false;
+ case JAVATYPE_MESSAGE: return true;
+
+ // No default because we want the compiler to complain if any new
+ // JavaTypes are added.
+ }
+
+ GOOGLE_LOG(FATAL) << "Can't get here.";
+ return false;
+}
+
+bool IsStringUtf8Handling(const FieldDescriptor* descriptor,
+ const Params params) {
+ return ((params.optimization() == JAVAMICRO_OPT_SPEED)
+ && (GetJavaType(descriptor) == JAVATYPE_STRING));
+}
+
+void SetPrimitiveVariables(const FieldDescriptor* descriptor, const Params params,
+ map<string, string>* variables) {
+ (*variables)["name"] =
+ UnderscoresToCamelCase(descriptor);
+ (*variables)["capitalized_name"] =
+ UnderscoresToCapitalizedCamelCase(descriptor);
+ (*variables)["number"] = SimpleItoa(descriptor->number());
+ if (IsStringUtf8Handling(descriptor, params)) {
+ (*variables)["type"] = "com.google.protobuf.micro.StringUtf8Micro";
+ string defaultValue = DefaultValue(params, descriptor);
+ if (defaultValue == "\"\"") {
+ (*variables)["default"] =
+ "com.google.protobuf.micro.StringUtf8Micro.EMPTY";
+ } else {
+ (*variables)["default"] = "new com.google.protobuf.micro.StringUtf8Micro("
+ + defaultValue + ")";
+ }
+ } else {
+ (*variables)["type"] = PrimitiveTypeName(GetJavaType(descriptor));
+ (*variables)["default"] = DefaultValue(params, descriptor);
+ }
+ (*variables)["boxed_type"] = BoxedPrimitiveTypeName(GetJavaType(descriptor));
+ (*variables)["capitalized_type"] = GetCapitalizedType(descriptor);
+ (*variables)["tag"] = SimpleItoa(WireFormat::MakeTag(descriptor));
+ (*variables)["tag_size"] = SimpleItoa(
+ WireFormat::TagSize(descriptor->number(), descriptor->type()));
+ if (IsReferenceType(GetJavaType(descriptor))) {
+ (*variables)["null_check"] =
+ " if (value == null) {\n"
+ " throw new NullPointerException();\n"
+ " }\n";
+ } else {
+ (*variables)["null_check"] = "";
+ }
+ int fixed_size = FixedSize(descriptor->type());
+ if (fixed_size != -1) {
+ (*variables)["fixed_size"] = SimpleItoa(fixed_size);
+ }
+ (*variables)["message_name"] = descriptor->containing_type()->name();
+}
+} // namespace
+
+// ===================================================================
+
+PrimitiveFieldGenerator::
+PrimitiveFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetPrimitiveVariables(descriptor, params, &variables_);
+}
+
+PrimitiveFieldGenerator::~PrimitiveFieldGenerator() {}
+
+void PrimitiveFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ printer->Print(variables_,
+ "private boolean has$capitalized_name$;\n"
+ "private $type$ $name$_ = $default$;\n"
+ "public boolean has$capitalized_name$() { return has$capitalized_name$; }\n");
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ "public String get$capitalized_name$() { return $name$_.getString(); }\n"
+ "public $type$ get$capitalized_name$StringUtf8() { return $name$_; }\n"
+ "public $message_name$ set$capitalized_name$(String value) {\n"
+ " has$capitalized_name$ = true;\n"
+ " if ($name$_ == $default$) {\n"
+ " $name$_ = new $type$(value);\n"
+ " } else {\n"
+ " $name$_.setString(value);\n"
+ " }\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " has$capitalized_name$ = false;\n"
+ " $name$_ = $default$;\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "public $type$ get$capitalized_name$() { return $name$_; }\n");
+ if (IsVariableLenType(GetJavaType(descriptor_))) {
+ printer->Print(variables_,
+ "public $message_name$ set$capitalized_name$($type$ value) {\n"
+ " has$capitalized_name$ = true;\n"
+ " $name$_ = value;\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " has$capitalized_name$ = false;\n"
+ " $name$_ = $default$;\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "public $message_name$ set$capitalized_name$($type$ value) {\n"
+ " has$capitalized_name$ = true;\n"
+ " $name$_ = value;\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " has$capitalized_name$ = false;\n"
+ " $name$_ = $default$;\n"
+ " return this;\n"
+ "}\n");
+ }
+ }
+}
+
+void PrimitiveFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "if (other.has$capitalized_name$()) {\n"
+ " set$capitalized_name$(other.get$capitalized_name$());\n"
+ "}\n");
+}
+
+void PrimitiveFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "set$capitalized_name$(input.read$capitalized_type$());\n");
+}
+
+void PrimitiveFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " output.writeStringUtf8($number$, get$capitalized_name$StringUtf8());\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " output.write$capitalized_type$($number$, get$capitalized_name$());\n"
+ "}\n");
+ }
+}
+
+void PrimitiveFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeStringUtf8Size($number$, get$capitalized_name$StringUtf8());\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "if (has$capitalized_name$()) {\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .compute$capitalized_type$Size($number$, get$capitalized_name$());\n"
+ "}\n");
+ }
+}
+
+string PrimitiveFieldGenerator::GetBoxedType() const {
+ return BoxedPrimitiveTypeName(GetJavaType(descriptor_));
+}
+
+// ===================================================================
+
+RepeatedPrimitiveFieldGenerator::
+RepeatedPrimitiveFieldGenerator(const FieldDescriptor* descriptor, const Params& params)
+ : FieldGenerator(params), descriptor_(descriptor) {
+ SetPrimitiveVariables(descriptor, params, &variables_);
+ if (descriptor_->options().packed()) {
+ GOOGLE_LOG(FATAL) << "MicroRuntime does not support packed";
+ }
+}
+
+RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {}
+
+void RepeatedPrimitiveFieldGenerator::
+GenerateMembers(io::Printer* printer) const {
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "private java.util.Vector $name$_ = new java.util.Vector();\n"
+ "public java.util.Vector get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public String get$capitalized_name$(int index) {\n"
+ " return (($type$)$name$_.elementAt(index)).getString();\n"
+ "}\n"
+ "public $type$ get$capitalized_name$StringUtf8(int index) {\n"
+ " return ($type$)$name$_.elementAt(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, String value) {\n"
+ "$null_check$"
+ " $name$_.setElementAt(new $type$(value), index);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$(String value) {\n"
+ "$null_check$"
+ " $name$_.addElement(new $type$(value));\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_.removeAllElements();\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "private java.util.List<$type$> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
+ "public java.util.List<$type$> get$capitalized_name$List() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public String get$capitalized_name$(int index) {\n"
+ " return $name$_.get(index).getString();\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, String value) {\n"
+ "$null_check$"
+ " $name$_.set(index, new $type$(value));\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$(String value) {\n"
+ "$null_check$"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = new java.util.ArrayList<$type$>();\n"
+ " }\n"
+ " $name$_.add(new $type$(value));\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_ = java.util.Collections.emptyList();\n"
+ " return this;\n"
+ "}\n");
+ }
+ } else if (params_.java_use_vector()) {
+ if (IsReferenceType(GetJavaType(descriptor_))) {
+ printer->Print(variables_,
+ "private java.util.Vector $name$_ = new java.util.Vector();\n"
+ "public java.util.Vector get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public $type$ get$capitalized_name$(int index) {\n"
+ " return ($type$) $name$_.elementAt(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, $type$ value) {\n"
+ "$null_check$"
+ " $name$_.setElementAt(value, index);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " $name$_.addElement(value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_.removeAllElements();\n"
+ " return this;\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "private java.util.Vector $name$_ = new java.util.Vector();\n"
+ "public java.util.Vector get$capitalized_name$List() {\n"
+ " return $name$_;\n"
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public $type$ get$capitalized_name$(int index) {\n"
+ " return (($boxed_type$)$name$_.elementAt(index)).$type$Value();\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, $type$ value) {\n"
+ "$null_check$"
+ " $name$_.setElementAt(new $boxed_type$(value), index);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " $name$_.addElement(new $boxed_type$(value));\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_.removeAllElements();\n"
+ " return this;\n"
+ "}\n");
+ }
+ } else {
+ printer->Print(variables_,
+ "private java.util.List<$boxed_type$> $name$_ =\n"
+ " java.util.Collections.emptyList();\n"
+ "public java.util.List<$boxed_type$> get$capitalized_name$List() {\n"
+ " return $name$_;\n" // note: unmodifiable list
+ "}\n"
+ "public int get$capitalized_name$Count() { return $name$_.size(); }\n"
+ "public $type$ get$capitalized_name$(int index) {\n"
+ " return $name$_.get(index);\n"
+ "}\n"
+ "public $message_name$ set$capitalized_name$(int index, $type$ value) {\n"
+ "$null_check$"
+ " $name$_.set(index, value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ add$capitalized_name$($type$ value) {\n"
+ "$null_check$"
+ " if ($name$_.isEmpty()) {\n"
+ " $name$_ = new java.util.ArrayList<$boxed_type$>();\n"
+ " }\n"
+ " $name$_.add(value);\n"
+ " return this;\n"
+ "}\n"
+ "public $message_name$ clear$capitalized_name$() {\n"
+ " $name$_ = java.util.Collections.emptyList();\n"
+ " return this;\n"
+ "}\n");
+ }
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "private int $name$MemoizedSerializedSize;\n");
+ }
+}
+
+void RepeatedPrimitiveFieldGenerator::
+GenerateMergingCode(io::Printer* printer) const {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "if (other.$name$_.size() != 0) {\n"
+ " for (int i = 0; i < other.$name$_.size(); i++)) {\n"
+ " result.$name$_.addElement(other.$name$_.elementAt(i));\n"
+ " }\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "if (!other.$name$_.isEmpty()) {\n"
+ " if (result.$name$_.isEmpty()) {\n"
+ " result.$name$_ = new java.util.ArrayList<$type$>();\n"
+ " }\n"
+ " result.$name$_.addAll(other.$name$_);\n"
+ "}\n");
+ }
+}
+
+void RepeatedPrimitiveFieldGenerator::
+GenerateParsingCode(io::Printer* printer) const {
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "int length = input.readRawVarint32();\n"
+ "int limit = input.pushLimit(length);\n"
+ "while (input.getBytesUntilLimit() > 0) {\n"
+ " add$capitalized_name$(input.read$capitalized_type$());\n"
+ "}\n"
+ "input.popLimit(limit);\n");
+ } else {
+ printer->Print(variables_,
+ "add$capitalized_name$(input.read$capitalized_type$());\n");
+ }
+}
+
+void RepeatedPrimitiveFieldGenerator::
+GenerateSerializationCode(io::Printer* printer) const {
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "if (get$capitalized_name$List().size() > 0) {\n"
+ " output.writeRawVarint32($tag$);\n"
+ " output.writeRawVarint32($name$MemoizedSerializedSize);\n"
+ "}\n");
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.write$capitalized_type$NoTag(get$capitalized_name$(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " output.write$capitalized_type$NoTag(element);\n"
+ "}\n");
+ }
+ } else {
+ if (params_.java_use_vector()) {
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.writeStringUtf8($number$, get$capitalized_name$StringUtf8(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " output.write$capitalized_type$($number$, get$capitalized_name$(i));\n"
+ "}\n");
+ }
+ } else {
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " output.writeStringUtf8($number$, element);\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " output.write$capitalized_type$($number$, element);\n"
+ "}\n");
+ }
+ }
+ }
+}
+
+void RepeatedPrimitiveFieldGenerator::
+GenerateSerializedSizeCode(io::Printer* printer) const {
+ printer->Print(variables_,
+ "{\n"
+ " int dataSize = 0;\n");
+ printer->Indent();
+
+ if (FixedSize(descriptor_->type()) == -1) {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "for (int i = 0; i < get$capitalized_name$List().size(); i++) {\n"
+ " dataSize += com.google.protobuf.micro.CodedOutputStreamMicro\n");
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ " .computeStringUtf8SizeNoTag(get$capitalized_name$StringUtf8(i));\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ " .compute$capitalized_type$SizeNoTag(($type$)get$capitalized_name$(i));\n"
+ "}\n");
+ }
+ } else {
+ printer->Print(variables_,
+ "for ($type$ element : get$capitalized_name$List()) {\n"
+ " dataSize += com.google.protobuf.micro.CodedOutputStreamMicro\n");
+ if (IsStringUtf8Handling(descriptor_, params_)) {
+ printer->Print(variables_,
+ " .computeStringUtf8SizeNoTag(element);\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ " .compute$capitalized_type$SizeNoTag(element);\n"
+ "}\n");
+ }
+ }
+ } else {
+ printer->Print(variables_,
+ "dataSize = $fixed_size$ * get$capitalized_name$List().size();\n");
+ }
+
+ printer->Print(
+ "size += dataSize;\n");
+
+ if (descriptor_->options().packed()) {
+ if (params_.java_use_vector()) {
+ printer->Print(variables_,
+ "if (get$capitalized_name$List().size() != 0) {\n");
+ } else {
+ printer->Print(variables_,
+ "if (!get$capitalized_name$List().isEmpty()) {\n");
+ }
+ printer->Print(variables_,
+ " size += $tag_size$;\n"
+ " size += com.google.protobuf.micro.CodedOutputStreamMicro\n"
+ " .computeInt32SizeNoTag(dataSize);\n"
+ "}\n");
+ } else {
+ printer->Print(variables_,
+ "size += $tag_size$ * get$capitalized_name$List().size();\n");
+ }
+
+ // cache the data size for packed fields.
+ if (descriptor_->options().packed()) {
+ printer->Print(variables_,
+ "$name$MemoizedSerializedSize = dataSize;\n");
+ }
+
+ printer->Outdent();
+ printer->Print("}\n");
+}
+
+string RepeatedPrimitiveFieldGenerator::GetBoxedType() const {
+ return BoxedPrimitiveTypeName(GetJavaType(descriptor_));
+}
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.h b/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.h
new file mode 100644
index 0000000..88d8eec
--- /dev/null
+++ b/src/google/protobuf/compiler/javamicro/javamicro_primitive_field.h
@@ -0,0 +1,94 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVAMICRO_PRIMITIVE_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVAMICRO_PRIMITIVE_FIELD_H__
+
+#include <map>
+#include <string>
+#include <google/protobuf/compiler/javamicro/javamicro_field.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javamicro {
+
+class PrimitiveFieldGenerator : public FieldGenerator {
+ public:
+ explicit PrimitiveFieldGenerator(const FieldDescriptor* descriptor, const Params ¶ms);
+ ~PrimitiveFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PrimitiveFieldGenerator);
+};
+
+class RepeatedPrimitiveFieldGenerator : public FieldGenerator {
+ public:
+ explicit RepeatedPrimitiveFieldGenerator(const FieldDescriptor* descriptor, const Params& params);
+ ~RepeatedPrimitiveFieldGenerator();
+
+ // implements FieldGenerator ---------------------------------------
+ void GenerateMembers(io::Printer* printer) const;
+ void GenerateMergingCode(io::Printer* printer) const;
+ void GenerateParsingCode(io::Printer* printer) const;
+ void GenerateSerializationCode(io::Printer* printer) const;
+ void GenerateSerializedSizeCode(io::Printer* printer) const;
+
+ string GetBoxedType() const;
+
+ private:
+ const FieldDescriptor* descriptor_;
+ map<string, string> variables_;
+
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedPrimitiveFieldGenerator);
+};
+
+} // namespace javamicro
+} // namespace compiler
+} // namespace protobuf
+
+} // namespace google
+#endif // GOOGLE_PROTOBUF_COMPILER_JAVAMICRO_PRIMITIVE_FIELD_H__
diff --git a/src/google/protobuf/compiler/main.cc b/src/google/protobuf/compiler/main.cc
index d9b0c3f..813a011 100644
--- a/src/google/protobuf/compiler/main.cc
+++ b/src/google/protobuf/compiler/main.cc
@@ -34,6 +34,7 @@
#include <google/protobuf/compiler/cpp/cpp_generator.h>
#include <google/protobuf/compiler/python/python_generator.h>
#include <google/protobuf/compiler/java/java_generator.h>
+#include <google/protobuf/compiler/javamicro/javamicro_generator.h>
int main(int argc, char* argv[]) {
@@ -57,5 +58,10 @@
cli.RegisterGenerator("--python_out", &py_generator,
"Generate Python source file.");
+ // Proto2 JavaMicro
+ google::protobuf::compiler::javamicro::JavaMicroGenerator javamicro_generator;
+ cli.RegisterGenerator("--javamicro_out", &javamicro_generator,
+ "Generate Java source file micro runtime.");
+
return cli.Run(argc, argv);
}
diff --git a/src/google/protobuf/unittest_import_micro.proto b/src/google/protobuf/unittest_import_micro.proto
new file mode 100644
index 0000000..adac807
--- /dev/null
+++ b/src/google/protobuf/unittest_import_micro.proto
@@ -0,0 +1,49 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// This is like unittest_import.proto but with optimize_for = MICRO_RUNTIME.
+
+package protobuf_unittest_import;
+
+// java_package and java_outer_classname are specified on the command line.
+//option java_package = "com.google.protobuf.micro";
+//option java_outer_classname = "UnittestImportMicro";
+
+message ImportMessageMicro {
+ optional int32 d = 1;
+}
+
+enum ImportEnumMicro {
+ IMPORT_MICRO_FOO = 7;
+ IMPORT_MICRO_BAR = 8;
+ IMPORT_MICRO_BAZ = 9;
+}
diff --git a/src/google/protobuf/unittest_micro.proto b/src/google/protobuf/unittest_micro.proto
new file mode 100644
index 0000000..3d7fcd2
--- /dev/null
+++ b/src/google/protobuf/unittest_micro.proto
@@ -0,0 +1,162 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: wink@google.com (Wink Saville)
+
+package protobuf_unittest;
+
+import "google/protobuf/unittest_import_micro.proto";
+
+option java_package = "com.google.protobuf.micro";
+option java_outer_classname = "MicroOuterClass";
+
+// Same as TestAllTypes but with the micro runtime.
+message TestAllTypesMicro {
+
+ message NestedMessage {
+ optional int32 bb = 1;
+ }
+
+ enum NestedEnum {
+ FOO = 1;
+ BAR = 2;
+ BAZ = 3;
+ }
+
+ // Singular
+ optional int32 optional_int32 = 1;
+ optional int64 optional_int64 = 2;
+ optional uint32 optional_uint32 = 3;
+ optional uint64 optional_uint64 = 4;
+ optional sint32 optional_sint32 = 5;
+ optional sint64 optional_sint64 = 6;
+ optional fixed32 optional_fixed32 = 7;
+ optional fixed64 optional_fixed64 = 8;
+ optional sfixed32 optional_sfixed32 = 9;
+ optional sfixed64 optional_sfixed64 = 10;
+ optional float optional_float = 11;
+ optional double optional_double = 12;
+ optional bool optional_bool = 13;
+ optional string optional_string = 14;
+ optional bytes optional_bytes = 15;
+
+ optional group OptionalGroup = 16 {
+ optional int32 a = 17;
+ }
+
+ optional NestedMessage optional_nested_message = 18;
+ optional ForeignMessageMicro optional_foreign_message = 19;
+ optional protobuf_unittest_import.ImportMessageMicro
+ optional_import_message = 20;
+
+ optional NestedEnum optional_nested_enum = 21;
+ optional ForeignEnumMicro optional_foreign_enum = 22;
+ optional protobuf_unittest_import.ImportEnumMicro optional_import_enum = 23;
+
+ optional string optional_string_piece = 24 [ctype=STRING_PIECE];
+ optional string optional_cord = 25 [ctype=CORD];
+
+ // Repeated
+ repeated int32 repeated_int32 = 31;
+ repeated int64 repeated_int64 = 32;
+ repeated uint32 repeated_uint32 = 33;
+ repeated uint64 repeated_uint64 = 34;
+ repeated sint32 repeated_sint32 = 35;
+ repeated sint64 repeated_sint64 = 36;
+ repeated fixed32 repeated_fixed32 = 37;
+ repeated fixed64 repeated_fixed64 = 38;
+ repeated sfixed32 repeated_sfixed32 = 39;
+ repeated sfixed64 repeated_sfixed64 = 40;
+ repeated float repeated_float = 41;
+ repeated double repeated_double = 42;
+ repeated bool repeated_bool = 43;
+ repeated string repeated_string = 44;
+ repeated bytes repeated_bytes = 45;
+
+ repeated group RepeatedGroup = 46 {
+ optional int32 a = 47;
+ }
+
+ repeated NestedMessage repeated_nested_message = 48;
+ repeated ForeignMessageMicro repeated_foreign_message = 49;
+ repeated protobuf_unittest_import.ImportMessageMicro
+ repeated_import_message = 50;
+
+ repeated NestedEnum repeated_nested_enum = 51;
+ repeated ForeignEnumMicro repeated_foreign_enum = 52;
+ repeated protobuf_unittest_import.ImportEnumMicro repeated_import_enum = 53;
+
+ repeated string repeated_string_piece = 54 [ctype=STRING_PIECE];
+ repeated string repeated_cord = 55 [ctype=CORD];
+
+ // Singular with defaults
+ optional int32 default_int32 = 61 [default = 41 ];
+ optional int64 default_int64 = 62 [default = 42 ];
+ optional uint32 default_uint32 = 63 [default = 43 ];
+ optional uint64 default_uint64 = 64 [default = 44 ];
+ optional sint32 default_sint32 = 65 [default = -45 ];
+ optional sint64 default_sint64 = 66 [default = 46 ];
+ optional fixed32 default_fixed32 = 67 [default = 47 ];
+ optional fixed64 default_fixed64 = 68 [default = 48 ];
+ optional sfixed32 default_sfixed32 = 69 [default = 49 ];
+ optional sfixed64 default_sfixed64 = 70 [default = -50 ];
+ optional float default_float = 71 [default = 51.5 ];
+ optional double default_double = 72 [default = 52e3 ];
+ optional bool default_bool = 73 [default = true ];
+ optional string default_string = 74 [default = "hello"];
+ optional bytes default_bytes = 75 [default = "world"];
+
+ optional NestedEnum default_nested_enum = 81 [default = BAR];
+ optional ForeignEnumMicro default_foreign_enum = 82
+ [default = FOREIGN_MICRO_BAR];
+ optional protobuf_unittest_import.ImportEnumMicro
+ default_import_enum = 83 [default = IMPORT_MICRO_BAR];
+
+ optional string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"];
+ optional string default_cord = 85 [ctype=CORD,default="123"];
+
+ required int32 id = 86;
+}
+
+message ForeignMessageMicro {
+ optional int32 c = 1;
+}
+
+enum ForeignEnumMicro {
+ FOREIGN_MICRO_FOO = 4;
+ FOREIGN_MICRO_BAR = 5;
+ FOREIGN_MICRO_BAZ = 6;
+}
+
+// Test that deprecated fields work. We only verify that they compile (at one
+// point this failed).
+message TestDeprecatedMicro {
+ optional int32 deprecated_field = 1 [deprecated = true];
+}
diff --git a/src/google/protobuf/unittest_recursive_micro.proto b/src/google/protobuf/unittest_recursive_micro.proto
new file mode 100644
index 0000000..a256852
--- /dev/null
+++ b/src/google/protobuf/unittest_recursive_micro.proto
@@ -0,0 +1,47 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: wink@google.com (Wink Saville)
+//
+
+package protobuf_unittest_import;
+
+option java_package = "com.google.protobuf.micro";
+
+message RecursiveMessageMicro {
+ message NestedMessage {
+ optional RecursiveMessageMicro a = 1;
+ }
+
+ required int32 id = 1;
+ optional NestedMessage nested_message = 2;
+ optional RecursiveMessageMicro optional_recursive_message_micro = 3;
+ repeated RecursiveMessageMicro repeated_recursive_message_micro = 4;
+}
diff --git a/src/google/protobuf/unittest_simple_micro.proto b/src/google/protobuf/unittest_simple_micro.proto
new file mode 100644
index 0000000..057bf3d
--- /dev/null
+++ b/src/google/protobuf/unittest_simple_micro.proto
@@ -0,0 +1,52 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: wink@google.com (Wink Saville)
+//
+
+package protobuf_unittest_import;
+
+option java_package = "com.google.protobuf.micro";
+
+message SimpleMessageMicro {
+ message NestedMessage {
+ optional int32 bb = 1;
+ }
+
+ enum NestedEnum {
+ FOO = 1;
+ BAR = 2;
+ BAZ = 3;
+ }
+
+ optional int32 d = 1 [default = 123];
+ optional NestedMessage nested_msg = 2;
+ optional NestedEnum default_nested_enum = 3 [default = BAZ];
+}
diff --git a/src/google/protobuf/unittest_stringutf8_micro.proto b/src/google/protobuf/unittest_stringutf8_micro.proto
new file mode 100644
index 0000000..e4bbe3d
--- /dev/null
+++ b/src/google/protobuf/unittest_stringutf8_micro.proto
@@ -0,0 +1,41 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: wink@google.com (Wink Saville)
+//
+
+package protobuf_unittest_import;
+
+option java_package = "com.google.protobuf.micro";
+
+message StringUtf8 {
+ optional string id = 1;
+ repeated string rs = 2;
+}
