The output of toString is now aligned with that used by non-nano and C++
runtimes, with the exception of groups. Groups should be serialized using a
camelized name (e.g. "FooBar" rather than "foo_bar") however the nano runtime
does not have information on which fields are groups.

Changes are:
  - bytes fields are output within double-quotes, non-printable characters are
    output as octal escape sequences (i.e. \NNN);
  - field identifiers are output in underscored format;
  - unset fields are not output (rather than printing "null");
  - the type name of the root message is not output.

With these changes the nano toString, normal toString, and C++'s DebugString all
produce equivalent output when given the same message. (Provided that message
uses no deprecated features.)

Change-Id: Id4791d73822846db29344db9f7bc3781c3e183a6

Follow upstream where they have any changes in 2.5.0

Change-Id: I3466e9c11242f533a9dff8c1afef4202dd100f2e

- Migrates getCachedSize to the MessageNano parent class to save one method per message.
- Create ExtendableMessageNano parent class for protos with extensions, this saves the
getExtension and setExtension methods on the relevant messages.
- getSerializedSize's default case (with no fields to serialize) also migrate to the
parent class, which saves methods on empty messages.
- Container classes become interfaces to save the constructor.

Change-Id: I81f1a1b6d6a660096835e9df3ea20456655aab4a

Strip the null elements out before serializing the array.
This is helpful in the cases where the user wants to construct
an array of an inexact size for serialization. For example:
User constructs array of size 5 because they anticipate adding
more than 1 element before serialization. Only 3 get added, so
the array looks like [Obj, Obj, Obj, null, null]. This would
curently crash without this CL.

All repeated fields of ref-type elements can contain null
elements: repeated strings, repeated bytes, and repeated
messages/groups.

Change-Id: I117391c868c9a436536d70d6151780e9cc7e8227

Conflicts:
	src/google/protobuf/compiler/javanano/javanano_message_field.cc

The option is only called 'generate_equals' because:
- equals() is the main thing; hashCode() is there only to
  complement equals();
- it's shorter;
- toString() should not be included in this option because
  it's more for debugging and it's more likely to stop
  ProGuard from working well.

Also shortened the "has bit" expression; was
((bitField & mask) == mask), now ((bitField & mask) != 0).
Both the Java code and the bytecode are slightly shorter.

Change-Id: Ic309a08a60883bf454eb6612679aa99611620e76

Also pre-inlines set() and has() in serialization code. This could
theoretically help ProGuard: the message class size is usually large,
and because of this only, it may refuse to inline an accessor into
the serialization code, and as a result keeps the accessor intact.
Chances are, after pre-inlining all accessor calls within the message
class, those accessors become unused or single-use, so there are more
reasons for ProGuard to inline and then remove them.

Change-Id: I57decbe0b2533c1be21439de0aad15f49c7024dd

- Blank line after opening a message class (but not an enum interface).
- Let all code blocks insert blank lines before themselves. This applies to
  'package' statement, all message classes, enum classes or constant groups,
  extensions, bitfields, proto fields (one block per field; i.e. accessors
  don't have blank lines among them), and basic MessageNano methods. In this
  case we don't need to guess what the next block is and create blank lines
  for it.
- Fixed some newline/indent errors.
- Only one SuppressWarnings("hiding") per file.

Change-Id: I865f52ad4fb6ea3b3a98b97ac9d78d19fc46c858

The public doc states that repeated fields are simply concatenated
and doesn't impose a different semantics for packed fields. This
CL fixes this for packed fields and adds tests covering all cases.

Also fixed a bit of missed null-repeated-field treatments.

Change-Id: Ie35277bb1a9f0b8171dc9d07b6adf9b9d3308de2

There's no distinction between a repeated field being null and being
empty. In both cases, nothing is sent on the wire. Clients might for
whatever reason inadvertently set a repeated field to null, so
protect against that and treat it just as if the field was empty.

Change-Id: Ic3846f7f2189d6cfff6f8ef3ca217daecc3c8be7

The field initializers have basically caused the compiled <init> method
to inline the whole clear() method, which means if ProGuard is not used
or failed to inline or remove clear(), there are two big chunks of code
that do the same thing. So why not just call clear() from the ctor.

Change-Id: Ief71e2b03db2e059b3bfa98309649368089ffab0

Change-Id: I7934a5b0444017aeda787501ebf8d9f9ba295c73

Previously it looked like this:

public final class OuterClass {
  [...]
  public static final class InnerClass extends
      com.google.protobuf.nano.MessageNano {
    [...]
    public void setId(java.lang.String value) {
      if (value == null) {
    throw new java.lang.NullPointerException();
  }
  id_ = value;
      bitfield0_ |= 0x00000001;
    [...]
  }
  [...]
}

Now it looks like this:

public final class OuterClass {
  [...]
  public static final class InnerClass extends
      com.google.protobuf.nano.MessageNano {
    [...]
    public void setId(java.lang.String value) {
      if (value == null) throw new java.lang.NullPointerException();
      id_ = value;
      bitfield0_ |= 0x00000001;
    [...]
  }
  [...]
}

Change-Id: I2a9289b528f785c846210d558206d677aa13e9be

This option generates fields as reference types, and serializes
based on nullness.

Change-Id: Ic32e0eebff59d14016cc9a19e15a9bb08ae0bba5
Signed-off-by: Brian Duff <bduff@google.com>

When parsing a group, the group's end tag should not be stored within the
message's unknownFieldData. Not only does this waste space, it is also output
the next time the group is serialized, resulting in two end tags for that group.
The resulting bytes are not always a valid protocol buffer and may fail to
parse.

This change ensures that group end tags do not result in an unknownFieldData
entry, and that messages with groups can be roundtripped without corruption.

Change-Id: I240f858a7217a7652b756598c34aacad5dcc3363

Conflicts:
	java/src/test/java/com/google/protobuf/NanoTest.java

This javanano_out command line option creates a container interface
at the normal place where the enum constants would reside, per enum
definition. The java_multiple_files flag would now affect the file-
scope enums with the shells. If the flag is true then file-scope
container interfaces are created in their own files.

Change-Id: Id52258fcff8d3dee9db8f3d8022147a811bf3565

This CL implements the 'optional_field_style=accessors' option.
All optional fields will now be 1 Java field and 1 bit in a shared
bitfield behind get/set/has/clear accessor methods. The setter
performs null check for reference types (Strings and byte[]s).

Also decentralized the clear code generation.

Change-Id: I60ac78329e352e76c2f8139fba1f292383080ad3

Change-Id: Ib9bb549602f71a451d2107fb04de17877553860e

enum_style = c | java: 'c' to put the enum member int constants
at the parent scope; 'java' to create uninstantiatable shell
classes at the parent scope and put the int constants inside.

optional_field_style = default | accessors: 'default' to create
one public mutable field per optional proto field; 'accessors'
to encapsulate the generated fields behind get, set, has and
clear accessors.

This CL only contains parsing code for these two parameters.

Change-Id: Iec0c3b0f30af8eb7db328e790664306bc90be089

Change-Id: I2dad2fd9f6c3d419fa77cf8162cd1ee49f74cc5d

- File class name is defined as the java_outer_classname option value
  or the file name ToCamelCase; never the single message's ClassName.
- File-scope enums are translated to constants in the file class,
  regardless of java_multiple_files.
- If java_multiple_files=true, and file's class name equals a message's
  class name, no error. This is done by detecting that the outer class
  is not needed and skipping the outer class codegen and clash checks.
  Note: there is a disparity between java[lite] and the previous
  java{micr|nan}o: when generating code for a single-message proto, the
  outer class is omitted by java{micr|nan}o if the file does not have
  java_outer_classname. This change makes java{micr|nan}o align with
  java[lite] codegen and create the outer class, but will print some
  info to warn of potential change of code.
- Also fixed the "is_own_file" detection and made all parseX() methods
  static. Previously, all messages in a java_multiple_files=true file
  are (incorrectly) considered to be in their own files, including
  nested messages, causing them to become inner classes (instance-
  bound) and forcing the parseX() methods to lose the static modifier.
- This change supersedes c/60164 and c/60086, which causes javanano to
  put enum values into enum shell classes if java_multiple_files=true.
  We now always use the parent class to host the enum values. A future
  change will add a command line option to provide more flexibility.
- Elaborated in java/README.txt.

Change-Id: I684932f90e0a028ef37c662b221def5ffa202439